MezzanineEngine 
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
scriptbindingxmllua51unsafe.cpp
1 /* ----------------------------------------------------------------------------
2  * This file was automatically generated by SWIG (http://www.swig.org).
3  * Version 2.0.10
4  *
5  * This file is not intended to be easily readable and contains a number of
6  * coding conventions designed to improve portability and efficiency. Do not make
7  * changes to this file unless you know what you are doing--modify the SWIG
8  * interface file instead.
9  * ----------------------------------------------------------------------------- */
10 
11 #define SWIGLUA
12 #define SWIG_LUA_TARGET SWIG_LUA_FLAVOR_LUA
13 #define SWIG_LUA_MODULE_GLOBAL
14 
15 
16 #ifdef __cplusplus
17 /* SwigValueWrapper is described in swig.swg */
18 template<typename T> class SwigValueWrapper {
19  struct SwigMovePointer {
20  T *ptr;
21  SwigMovePointer(T *p) : ptr(p) { }
22  ~SwigMovePointer() { delete ptr; }
23  SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
24  } pointer;
25  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
27 public:
28  SwigValueWrapper() : pointer(0) { }
29  SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
30  operator T&() const { return *pointer.ptr; }
31  T *operator&() { return pointer.ptr; }
32 };
33 
34 template <typename T> T SwigValueInit() {
35  return T();
36 }
37 #endif
38 
39 /* -----------------------------------------------------------------------------
40  * This section contains generic SWIG labels for method/variable
41  * declarations/attributes, and other compiler dependent labels.
42  * ----------------------------------------------------------------------------- */
43 
44 /* template workaround for compilers that cannot correctly implement the C++ standard */
45 #ifndef SWIGTEMPLATEDISAMBIGUATOR
46 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
47 # define SWIGTEMPLATEDISAMBIGUATOR template
48 # elif defined(__HP_aCC)
49 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
50 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
51 # define SWIGTEMPLATEDISAMBIGUATOR template
52 # else
53 # define SWIGTEMPLATEDISAMBIGUATOR
54 # endif
55 #endif
56 
57 /* inline attribute */
58 #ifndef SWIGINLINE
59 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
60 # define SWIGINLINE inline
61 # else
62 # define SWIGINLINE
63 # endif
64 #endif
65 
66 /* attribute recognised by some compilers to avoid 'unused' warnings */
67 #ifndef SWIGUNUSED
68 # if defined(__GNUC__)
69 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
70 # define SWIGUNUSED __attribute__ ((__unused__))
71 # else
72 # define SWIGUNUSED
73 # endif
74 # elif defined(__ICC)
75 # define SWIGUNUSED __attribute__ ((__unused__))
76 # else
77 # define SWIGUNUSED
78 # endif
79 #endif
80 
81 #ifndef SWIG_MSC_UNSUPPRESS_4505
82 # if defined(_MSC_VER)
83 # pragma warning(disable : 4505) /* unreferenced local function has been removed */
84 # endif
85 #endif
86 
87 #ifndef SWIGUNUSEDPARM
88 # ifdef __cplusplus
89 # define SWIGUNUSEDPARM(p)
90 # else
91 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
92 # endif
93 #endif
94 
95 /* internal SWIG method */
96 #ifndef SWIGINTERN
97 # define SWIGINTERN static SWIGUNUSED
98 #endif
99 
100 /* internal inline SWIG method */
101 #ifndef SWIGINTERNINLINE
102 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
103 #endif
104 
105 /* exporting methods */
106 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
107 # ifndef GCC_HASCLASSVISIBILITY
108 # define GCC_HASCLASSVISIBILITY
109 # endif
110 #endif
111 
112 #ifndef SWIGEXPORT
113 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
114 # if defined(STATIC_LINKED)
115 # define SWIGEXPORT
116 # else
117 # define SWIGEXPORT __declspec(dllexport)
118 # endif
119 # else
120 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
121 # define SWIGEXPORT __attribute__ ((visibility("default")))
122 # else
123 # define SWIGEXPORT
124 # endif
125 # endif
126 #endif
127 
128 /* calling conventions for Windows */
129 #ifndef SWIGSTDCALL
130 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
131 # define SWIGSTDCALL __stdcall
132 # else
133 # define SWIGSTDCALL
134 # endif
135 #endif
136 
137 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
138 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
139 # define _CRT_SECURE_NO_DEPRECATE
140 #endif
141 
142 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
143 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
144 # define _SCL_SECURE_NO_DEPRECATE
145 #endif
146 
147 
148 /* -----------------------------------------------------------------------------
149  * swigrun.swg
150  *
151  * This file contains generic C API SWIG runtime support for pointer
152  * type checking.
153  * ----------------------------------------------------------------------------- */
154 
155 /* This should only be incremented when either the layout of swig_type_info changes,
156  or for whatever reason, the runtime changes incompatibly */
157 #define SWIG_RUNTIME_VERSION "4"
158 
159 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
160 #ifdef SWIG_TYPE_TABLE
161 # define SWIG_QUOTE_STRING(x) #x
162 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
163 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
164 #else
165 # define SWIG_TYPE_TABLE_NAME
166 #endif
167 
168 /*
169  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
170  creating a static or dynamic library from the SWIG runtime code.
171  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
172 
173  But only do this if strictly necessary, ie, if you have problems
174  with your compiler or suchlike.
175 */
176 
177 #ifndef SWIGRUNTIME
178 # define SWIGRUNTIME SWIGINTERN
179 #endif
180 
181 #ifndef SWIGRUNTIMEINLINE
182 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
183 #endif
184 
185 /* Generic buffer size */
186 #ifndef SWIG_BUFFER_SIZE
187 # define SWIG_BUFFER_SIZE 1024
188 #endif
189 
190 /* Flags for pointer conversions */
191 #define SWIG_POINTER_DISOWN 0x1
192 #define SWIG_CAST_NEW_MEMORY 0x2
193 
194 /* Flags for new pointer objects */
195 #define SWIG_POINTER_OWN 0x1
196 
197 
198 /*
199  Flags/methods for returning states.
200 
201  The SWIG conversion methods, as ConvertPtr, return an integer
202  that tells if the conversion was successful or not. And if not,
203  an error code can be returned (see swigerrors.swg for the codes).
204 
205  Use the following macros/flags to set or process the returning
206  states.
207 
208  In old versions of SWIG, code such as the following was usually written:
209 
210  if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
211  // success code
212  } else {
213  //fail code
214  }
215 
216  Now you can be more explicit:
217 
218  int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
219  if (SWIG_IsOK(res)) {
220  // success code
221  } else {
222  // fail code
223  }
224 
225  which is the same really, but now you can also do
226 
227  Type *ptr;
228  int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
229  if (SWIG_IsOK(res)) {
230  // success code
231  if (SWIG_IsNewObj(res) {
232  ...
233  delete *ptr;
234  } else {
235  ...
236  }
237  } else {
238  // fail code
239  }
240 
241  I.e., now SWIG_ConvertPtr can return new objects and you can
242  identify the case and take care of the deallocation. Of course that
243  also requires SWIG_ConvertPtr to return new result values, such as
244 
245  int SWIG_ConvertPtr(obj, ptr,...) {
246  if (<obj is ok>) {
247  if (<need new object>) {
248  *ptr = <ptr to new allocated object>;
249  return SWIG_NEWOBJ;
250  } else {
251  *ptr = <ptr to old object>;
252  return SWIG_OLDOBJ;
253  }
254  } else {
255  return SWIG_BADOBJ;
256  }
257  }
258 
259  Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
260  more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
261  SWIG errors code.
262 
263  Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
264  allows to return the 'cast rank', for example, if you have this
265 
266  int food(double)
267  int fooi(int);
268 
269  and you call
270 
271  food(1) // cast rank '1' (1 -> 1.0)
272  fooi(1) // cast rank '0'
273 
274  just use the SWIG_AddCast()/SWIG_CheckState()
275 */
276 
277 #define SWIG_OK (0)
278 #define SWIG_ERROR (-1)
279 #define SWIG_IsOK(r) (r >= 0)
280 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
281 
282 /* The CastRankLimit says how many bits are used for the cast rank */
283 #define SWIG_CASTRANKLIMIT (1 << 8)
284 /* The NewMask denotes the object was created (using new/malloc) */
285 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
286 /* The TmpMask is for in/out typemaps that use temporal objects */
287 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
288 /* Simple returning values */
289 #define SWIG_BADOBJ (SWIG_ERROR)
290 #define SWIG_OLDOBJ (SWIG_OK)
291 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
292 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
293 /* Check, add and del mask methods */
294 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
295 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
296 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
297 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
298 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
299 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
300 
301 /* Cast-Rank Mode */
302 #if defined(SWIG_CASTRANK_MODE)
303 # ifndef SWIG_TypeRank
304 # define SWIG_TypeRank unsigned long
305 # endif
306 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
307 # define SWIG_MAXCASTRANK (2)
308 # endif
309 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
310 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
311 SWIGINTERNINLINE int SWIG_AddCast(int r) {
312  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
313 }
314 SWIGINTERNINLINE int SWIG_CheckState(int r) {
315  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
316 }
317 #else /* no cast-rank mode */
318 # define SWIG_AddCast(r) (r)
319 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
320 #endif
321 
322 
323 #include <string.h>
324 
325 #ifdef __cplusplus
326 extern "C" {
327 #endif
328 
329 typedef void *(*swig_converter_func)(void *, int *);
330 typedef struct swig_type_info *(*swig_dycast_func)(void **);
331 
332 /* Structure to store information on one type */
333 typedef struct swig_type_info {
334  const char *name; /* mangled name of this type */
335  const char *str; /* human readable name of this type */
336  swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
337  struct swig_cast_info *cast; /* linked list of types that can cast into this type */
338  void *clientdata; /* language specific type data */
339  int owndata; /* flag if the structure owns the clientdata */
341 
342 /* Structure to store a type and conversion function used for casting */
343 typedef struct swig_cast_info {
344  swig_type_info *type; /* pointer to type that is equivalent to this type */
345  swig_converter_func converter; /* function to cast the void pointers */
346  struct swig_cast_info *next; /* pointer to next cast in linked list */
347  struct swig_cast_info *prev; /* pointer to the previous cast */
349 
350 /* Structure used to store module information
351  * Each module generates one structure like this, and the runtime collects
352  * all of these structures and stores them in a circularly linked list.*/
353 typedef struct swig_module_info {
354  swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
355  size_t size; /* Number of types in this module */
356  struct swig_module_info *next; /* Pointer to next element in circularly linked list */
357  swig_type_info **type_initial; /* Array of initially generated type structures */
358  swig_cast_info **cast_initial; /* Array of initially generated casting structures */
359  void *clientdata; /* Language specific module data */
361 
362 /*
363  Compare two type names skipping the space characters, therefore
364  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
365 
366  Return 0 when the two name types are equivalent, as in
367  strncmp, but skipping ' '.
368 */
369 SWIGRUNTIME int
370 SWIG_TypeNameComp(const char *f1, const char *l1,
371  const char *f2, const char *l2) {
372  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
373  while ((*f1 == ' ') && (f1 != l1)) ++f1;
374  while ((*f2 == ' ') && (f2 != l2)) ++f2;
375  if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
376  }
377  return (int)((l1 - f1) - (l2 - f2));
378 }
379 
380 /*
381  Check type equivalence in a name list like <name1>|<name2>|...
382  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
383 */
384 SWIGRUNTIME int
385 SWIG_TypeCmp(const char *nb, const char *tb) {
386  int equiv = 1;
387  const char* te = tb + strlen(tb);
388  const char* ne = nb;
389  while (equiv != 0 && *ne) {
390  for (nb = ne; *ne; ++ne) {
391  if (*ne == '|') break;
392  }
393  equiv = SWIG_TypeNameComp(nb, ne, tb, te);
394  if (*ne) ++ne;
395  }
396  return equiv;
397 }
398 
399 /*
400  Check type equivalence in a name list like <name1>|<name2>|...
401  Return 0 if not equal, 1 if equal
402 */
403 SWIGRUNTIME int
404 SWIG_TypeEquiv(const char *nb, const char *tb) {
405  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
406 }
407 
408 /*
409  Check the typename
410 */
411 SWIGRUNTIME swig_cast_info *
412 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
413  if (ty) {
414  swig_cast_info *iter = ty->cast;
415  while (iter) {
416  if (strcmp(iter->type->name, c) == 0) {
417  if (iter == ty->cast)
418  return iter;
419  /* Move iter to the top of the linked list */
420  iter->prev->next = iter->next;
421  if (iter->next)
422  iter->next->prev = iter->prev;
423  iter->next = ty->cast;
424  iter->prev = 0;
425  if (ty->cast) ty->cast->prev = iter;
426  ty->cast = iter;
427  return iter;
428  }
429  iter = iter->next;
430  }
431  }
432  return 0;
433 }
434 
435 /*
436  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
437 */
438 SWIGRUNTIME swig_cast_info *
439 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
440  if (ty) {
441  swig_cast_info *iter = ty->cast;
442  while (iter) {
443  if (iter->type == from) {
444  if (iter == ty->cast)
445  return iter;
446  /* Move iter to the top of the linked list */
447  iter->prev->next = iter->next;
448  if (iter->next)
449  iter->next->prev = iter->prev;
450  iter->next = ty->cast;
451  iter->prev = 0;
452  if (ty->cast) ty->cast->prev = iter;
453  ty->cast = iter;
454  return iter;
455  }
456  iter = iter->next;
457  }
458  }
459  return 0;
460 }
461 
462 /*
463  Cast a pointer up an inheritance hierarchy
464 */
465 SWIGRUNTIMEINLINE void *
466 SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
467  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
468 }
469 
470 /*
471  Dynamic pointer casting. Down an inheritance hierarchy
472 */
473 SWIGRUNTIME swig_type_info *
474 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
475  swig_type_info *lastty = ty;
476  if (!ty || !ty->dcast) return ty;
477  while (ty && (ty->dcast)) {
478  ty = (*ty->dcast)(ptr);
479  if (ty) lastty = ty;
480  }
481  return lastty;
482 }
483 
484 /*
485  Return the name associated with this type
486 */
487 SWIGRUNTIMEINLINE const char *
488 SWIG_TypeName(const swig_type_info *ty) {
489  return ty->name;
490 }
491 
492 /*
493  Return the pretty name associated with this type,
494  that is an unmangled type name in a form presentable to the user.
495 */
496 SWIGRUNTIME const char *
497 SWIG_TypePrettyName(const swig_type_info *type) {
498  /* The "str" field contains the equivalent pretty names of the
499  type, separated by vertical-bar characters. We choose
500  to print the last name, as it is often (?) the most
501  specific. */
502  if (!type) return NULL;
503  if (type->str != NULL) {
504  const char *last_name = type->str;
505  const char *s;
506  for (s = type->str; *s; s++)
507  if (*s == '|') last_name = s+1;
508  return last_name;
509  }
510  else
511  return type->name;
512 }
513 
514 /*
515  Set the clientdata field for a type
516 */
517 SWIGRUNTIME void
518 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
519  swig_cast_info *cast = ti->cast;
520  /* if (ti->clientdata == clientdata) return; */
521  ti->clientdata = clientdata;
522 
523  while (cast) {
524  if (!cast->converter) {
525  swig_type_info *tc = cast->type;
526  if (!tc->clientdata) {
527  SWIG_TypeClientData(tc, clientdata);
528  }
529  }
530  cast = cast->next;
531  }
532 }
533 SWIGRUNTIME void
534 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
535  SWIG_TypeClientData(ti, clientdata);
536  ti->owndata = 1;
537 }
538 
539 /*
540  Search for a swig_type_info structure only by mangled name
541  Search is a O(log #types)
542 
543  We start searching at module start, and finish searching when start == end.
544  Note: if start == end at the beginning of the function, we go all the way around
545  the circular list.
546 */
547 SWIGRUNTIME swig_type_info *
548 SWIG_MangledTypeQueryModule(swig_module_info *start,
549  swig_module_info *end,
550  const char *name) {
551  swig_module_info *iter = start;
552  do {
553  if (iter->size) {
554  register size_t l = 0;
555  register size_t r = iter->size - 1;
556  do {
557  /* since l+r >= 0, we can (>> 1) instead (/ 2) */
558  register size_t i = (l + r) >> 1;
559  const char *iname = iter->types[i]->name;
560  if (iname) {
561  register int compare = strcmp(name, iname);
562  if (compare == 0) {
563  return iter->types[i];
564  } else if (compare < 0) {
565  if (i) {
566  r = i - 1;
567  } else {
568  break;
569  }
570  } else if (compare > 0) {
571  l = i + 1;
572  }
573  } else {
574  break; /* should never happen */
575  }
576  } while (l <= r);
577  }
578  iter = iter->next;
579  } while (iter != end);
580  return 0;
581 }
582 
583 /*
584  Search for a swig_type_info structure for either a mangled name or a human readable name.
585  It first searches the mangled names of the types, which is a O(log #types)
586  If a type is not found it then searches the human readable names, which is O(#types).
587 
588  We start searching at module start, and finish searching when start == end.
589  Note: if start == end at the beginning of the function, we go all the way around
590  the circular list.
591 */
592 SWIGRUNTIME swig_type_info *
593 SWIG_TypeQueryModule(swig_module_info *start,
594  swig_module_info *end,
595  const char *name) {
596  /* STEP 1: Search the name field using binary search */
597  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
598  if (ret) {
599  return ret;
600  } else {
601  /* STEP 2: If the type hasn't been found, do a complete search
602  of the str field (the human readable name) */
603  swig_module_info *iter = start;
604  do {
605  register size_t i = 0;
606  for (; i < iter->size; ++i) {
607  if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
608  return iter->types[i];
609  }
610  iter = iter->next;
611  } while (iter != end);
612  }
613 
614  /* neither found a match */
615  return 0;
616 }
617 
618 /*
619  Pack binary data into a string
620 */
621 SWIGRUNTIME char *
622 SWIG_PackData(char *c, void *ptr, size_t sz) {
623  static const char hex[17] = "0123456789abcdef";
624  register const unsigned char *u = (unsigned char *) ptr;
625  register const unsigned char *eu = u + sz;
626  for (; u != eu; ++u) {
627  register unsigned char uu = *u;
628  *(c++) = hex[(uu & 0xf0) >> 4];
629  *(c++) = hex[uu & 0xf];
630  }
631  return c;
632 }
633 
634 /*
635  Unpack binary data from a string
636 */
637 SWIGRUNTIME const char *
638 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
639  register unsigned char *u = (unsigned char *) ptr;
640  register const unsigned char *eu = u + sz;
641  for (; u != eu; ++u) {
642  register char d = *(c++);
643  register unsigned char uu;
644  if ((d >= '0') && (d <= '9'))
645  uu = ((d - '0') << 4);
646  else if ((d >= 'a') && (d <= 'f'))
647  uu = ((d - ('a'-10)) << 4);
648  else
649  return (char *) 0;
650  d = *(c++);
651  if ((d >= '0') && (d <= '9'))
652  uu |= (d - '0');
653  else if ((d >= 'a') && (d <= 'f'))
654  uu |= (d - ('a'-10));
655  else
656  return (char *) 0;
657  *u = uu;
658  }
659  return c;
660 }
661 
662 /*
663  Pack 'void *' into a string buffer.
664 */
665 SWIGRUNTIME char *
666 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
667  char *r = buff;
668  if ((2*sizeof(void *) + 2) > bsz) return 0;
669  *(r++) = '_';
670  r = SWIG_PackData(r,&ptr,sizeof(void *));
671  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
672  strcpy(r,name);
673  return buff;
674 }
675 
676 SWIGRUNTIME const char *
677 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
678  if (*c != '_') {
679  if (strcmp(c,"NULL") == 0) {
680  *ptr = (void *) 0;
681  return name;
682  } else {
683  return 0;
684  }
685  }
686  return SWIG_UnpackData(++c,ptr,sizeof(void *));
687 }
688 
689 SWIGRUNTIME char *
690 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
691  char *r = buff;
692  size_t lname = (name ? strlen(name) : 0);
693  if ((2*sz + 2 + lname) > bsz) return 0;
694  *(r++) = '_';
695  r = SWIG_PackData(r,ptr,sz);
696  if (lname) {
697  strncpy(r,name,lname+1);
698  } else {
699  *r = 0;
700  }
701  return buff;
702 }
703 
704 SWIGRUNTIME const char *
705 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
706  if (*c != '_') {
707  if (strcmp(c,"NULL") == 0) {
708  memset(ptr,0,sz);
709  return name;
710  } else {
711  return 0;
712  }
713  }
714  return SWIG_UnpackData(++c,ptr,sz);
715 }
716 
717 #ifdef __cplusplus
718 }
719 #endif
720 
721 /* -----------------------------------------------------------------------------
722  * luarun.swg
723  *
724  * This file contains the runtime support for Lua modules
725  * and includes code for managing global variables and pointer
726  * type checking.
727  * ----------------------------------------------------------------------------- */
728 
729 #ifdef __cplusplus
730 extern "C" {
731 #endif
732 
733 #include "lua.h"
734 #include "lauxlib.h"
735 #include <stdlib.h> /* for malloc */
736 #include <assert.h> /* for a few sanity tests */
737 
738 /* -----------------------------------------------------------------------------
739  * Lua flavors
740  * ----------------------------------------------------------------------------- */
741 
742 #define SWIG_LUA_FLAVOR_LUA 1
743 #define SWIG_LUA_FLAVOR_ELUA 2
744 #define SWIG_LUA_FLAVOR_ELUAC 3
745 
746 #if !defined(SWIG_LUA_TARGET)
747 # error SWIG_LUA_TARGET not defined
748 #endif
749 
750 #if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC)
751 # define SWIG_LUA_CONSTTAB_INT(B, C) LSTRKEY(B), LNUMVAL(C)
752 # define SWIG_LUA_CONSTTAB_FLOAT(B, C) LSTRKEY(B), LNUMVAL(C)
753 # define SWIG_LUA_CONSTTAB_STRING(B, C) LSTRKEY(B), LSTRVAL(C)
754 # define SWIG_LUA_CONSTTAB_CHAR(B, C) LSTRKEY(B), LNUMVAL(C)
755 #else /* SWIG_LUA_FLAVOR_LUA */
756 # define SWIG_LUA_CONSTTAB_INT(B, C) SWIG_LUA_INT, (char *)B, (long)C, 0, 0, 0
757 # define SWIG_LUA_CONSTTAB_FLOAT(B, C) SWIG_LUA_FLOAT, (char *)B, 0, (double)C, 0, 0
758 # define SWIG_LUA_CONSTTAB_STRING(B, C) SWIG_LUA_STRING, (char *)B, 0, 0, (void *)C, 0
759 # define SWIG_LUA_CONSTTAB_CHAR(B, C) SWIG_LUA_CHAR, (char *)B, (long)C, 0, 0, 0
760 #endif
761 
762 #if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC)
763 # define LRO_STRVAL(v) {{.p = (char *) v}, LUA_TSTRING}
764 # define LSTRVAL LRO_STRVAL
765 #endif
766 
767 /* -----------------------------------------------------------------------------
768  * compatibility defines
769  * ----------------------------------------------------------------------------- */
770 
771 /* History of Lua C API length functions: In Lua 5.0 (and before?)
772  there was "lua_strlen". In Lua 5.1, this was renamed "lua_objlen",
773  but a compatibility define of "lua_strlen" was added. In Lua 5.2,
774  this function was again renamed, to "lua_rawlen" (to emphasize that
775  it doesn't call the "__len" metamethod), and the compatibility
776  define of lua_strlen was removed. All SWIG uses have been updated
777  to "lua_rawlen", and we add our own defines of that here for older
778  versions of Lua. */
779 #if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 501
780 # define lua_rawlen lua_strlen
781 #elif LUA_VERSION_NUM == 501
782 # define lua_rawlen lua_objlen
783 #endif
784 
785 
786 /* lua_pushglobaltable is the recommended "future-proof" way to get
787  the global table for Lua 5.2 and later. Here we define
788  lua_pushglobaltable ourselves for Lua versions before 5.2. */
789 #if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 502
790 # define lua_pushglobaltable(L) lua_pushvalue(L, LUA_GLOBALSINDEX)
791 #endif
792 
793 
794 /* -----------------------------------------------------------------------------
795  * global swig types
796  * ----------------------------------------------------------------------------- */
797 /* Constant table */
798 #define SWIG_LUA_INT 1
799 #define SWIG_LUA_FLOAT 2
800 #define SWIG_LUA_STRING 3
801 #define SWIG_LUA_POINTER 4
802 #define SWIG_LUA_BINARY 5
803 #define SWIG_LUA_CHAR 6
804 
805 /* Structure for variable linking table */
806 typedef struct {
807  const char *name;
808  lua_CFunction get;
809  lua_CFunction set;
811 
812 /* Constant information structure */
813 typedef struct {
814  int type;
815  char *name;
816  long lvalue;
817  double dvalue;
818  void *pvalue;
819  swig_type_info **ptype;
821 
822 typedef struct {
823  const char *name;
824  lua_CFunction method;
826 
827 typedef struct {
828  const char *name;
829  lua_CFunction getmethod;
830  lua_CFunction setmethod;
832 
833 typedef struct swig_lua_class {
834  const char *name;
835  swig_type_info **type;
836  lua_CFunction constructor;
837  void (*destructor)(void *);
838  swig_lua_method *methods;
839  swig_lua_attribute *attributes;
840  struct swig_lua_class **bases;
841  const char **base_names;
843 
844 /* this is the struct for wrapping all pointers in SwigLua
845 */
846 typedef struct {
847  swig_type_info *type;
848  int own; /* 1 if owned & must be destroyed */
849  void *ptr;
851 
852 /* this is the struct for wrapping arbitrary packed binary data
853 (currently it is only used for member function pointers)
854 the data ordering is similar to swig_lua_userdata, but it is currently not possible
855 to tell the two structures apart within SWIG, other than by looking at the type
856 */
857 typedef struct {
858  swig_type_info *type;
859  int own; /* 1 if owned & must be destroyed */
860  char data[1]; /* arbitary amount of data */
862 
863 /* Common SWIG API */
864 #define SWIG_NewPointerObj(L, ptr, type, owner) SWIG_Lua_NewPointerObj(L, (void *)ptr, type, owner)
865 #define SWIG_ConvertPtr(L,idx, ptr, type, flags) SWIG_Lua_ConvertPtr(L,idx,ptr,type,flags)
866 #define SWIG_MustGetPtr(L,idx, type,flags, argnum,fnname) SWIG_Lua_MustGetPtr(L,idx, type,flags, argnum,fnname)
867 /* for C++ member pointers, ie, member methods */
868 #define SWIG_ConvertMember(L, idx, ptr, sz, ty) SWIG_Lua_ConvertPacked(L, idx, ptr, sz, ty)
869 #define SWIG_NewMemberObj(L, ptr, sz, type) SWIG_Lua_NewPackedObj(L, ptr, sz, type)
870 
871 /* Runtime API */
872 #define SWIG_GetModule(clientdata) SWIG_Lua_GetModule((lua_State*)(clientdata))
873 #define SWIG_SetModule(clientdata, pointer) SWIG_Lua_SetModule((lua_State*) (clientdata), pointer)
874 #define SWIG_MODULE_CLIENTDATA_TYPE lua_State*
875 
876 /* Contract support */
877 #define SWIG_contract_assert(expr, msg) \
878  if (!(expr)) { lua_pushstring(L, (char *) msg); goto fail; } else
879 
880 /* helper #defines */
881 #define SWIG_fail {goto fail;}
882 #define SWIG_fail_arg(func_name,argnum,type) \
883  {lua_pushfstring(L,"Error in %s (arg %d), expected '%s' got '%s'",\
884  func_name,argnum,type,SWIG_Lua_typename(L,argnum));\
885  goto fail;}
886 #define SWIG_fail_ptr(func_name,argnum,type) \
887  SWIG_fail_arg(func_name,argnum,(type && type->str)?type->str:"void*")
888 #define SWIG_check_num_args(func_name,a,b) \
889  if (lua_gettop(L)<a || lua_gettop(L)>b) \
890  {lua_pushfstring(L,"Error in %s expected %d..%d args, got %d",func_name,a,b,lua_gettop(L));\
891  goto fail;}
892 
893 
894 #define SWIG_Lua_get_table(L,n) \
895  (lua_pushstring(L, n), lua_rawget(L,-2))
896 
897 #define SWIG_Lua_add_function(L,n,f) \
898  (lua_pushstring(L, n), \
899  lua_pushcfunction(L, f), \
900  lua_rawset(L,-3))
901 
902 /* special helper for allowing 'nil' for usertypes */
903 #define SWIG_isptrtype(L,I) (lua_isuserdata(L,I) || lua_isnil(L,I))
904 
905 #ifdef __cplusplus
906 /* Special helper for member function pointers
907 it gets the address, casts it, then dereferences it */
908 //#define SWIG_mem_fn_as_voidptr(a) (*((char**)&(a)))
909 #endif
910 
911 /* storing/access of swig_module_info */
912 SWIGRUNTIME swig_module_info *
913 SWIG_Lua_GetModule(lua_State* L) {
914  swig_module_info *ret = 0;
915  lua_pushstring(L,"swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME);
916  lua_rawget(L,LUA_REGISTRYINDEX);
917  if (lua_islightuserdata(L,-1))
918  ret=(swig_module_info*)lua_touserdata(L,-1);
919  lua_pop(L,1); /* tidy */
920  return ret;
921 }
922 
923 SWIGRUNTIME void
924 SWIG_Lua_SetModule(lua_State* L, swig_module_info *module) {
925  /* add this all into the Lua registry: */
926  lua_pushstring(L,"swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME);
927  lua_pushlightuserdata(L,(void*)module);
928  lua_rawset(L,LUA_REGISTRYINDEX);
929 }
930 
931 /* -----------------------------------------------------------------------------
932  * global variable support code: modules
933  * ----------------------------------------------------------------------------- */
934 
935 /* this function is called when trying to set an immutable.
936 default action is to print an error.
937 This can removed with a compile flag SWIGLUA_IGNORE_SET_IMMUTABLE */
938 SWIGINTERN int SWIG_Lua_set_immutable(lua_State* L)
939 {
940 /* there should be 1 param passed in: the new value */
941 #ifndef SWIGLUA_IGNORE_SET_IMMUTABLE
942  lua_pop(L,1); /* remove it */
943  lua_pushstring(L,"This variable is immutable");
944  lua_error(L);
945 #endif
946  return 0; /* should not return anything */
947 }
948 
949 /* the module.get method used for getting linked data */
950 SWIGINTERN int SWIG_Lua_module_get(lua_State* L)
951 {
952 /* there should be 2 params passed in
953  (1) table (not the meta table)
954  (2) string name of the attribute
955  printf("SWIG_Lua_module_get %p(%s) '%s'\n",
956  lua_topointer(L,1),lua_typename(L,lua_type(L,1)),
957  lua_tostring(L,2));
958 */
959  /* get the metatable */
960 #if ((SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC))
961  assert(lua_isrotable(L,1)); /* just in case */
962 #else
963  assert(lua_istable(L,1)); /* default Lua action */
964 #endif
965  lua_getmetatable(L,1); /* get the metatable */
966 #if ((SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC))
967  assert(lua_isrotable(L,-1)); /* just in case */
968 #else
969  assert(lua_istable(L,-1));
970 #endif
971  SWIG_Lua_get_table(L,".get"); /* get the .get table */
972  lua_remove(L,3); /* remove metatable */
973 #if ((SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC))
974  if (lua_isrotable(L,-1))
975 #else
976  if (lua_istable(L,-1))
977 #endif
978  {
979  /* look for the key in the .get table */
980  lua_pushvalue(L,2); /* key */
981  lua_rawget(L,-2);
982  lua_remove(L,3); /* remove .get */
983  if (lua_iscfunction(L,-1))
984  { /* found it so call the fn & return its value */
985  lua_call(L,0,1);
986  return 1;
987  }
988  lua_pop(L,1); /* remove the top */
989  }
990  lua_pop(L,1); /* remove the .get */
991  lua_pushnil(L); /* return a nil */
992  return 1;
993 }
994 
995 /* the module.set method used for setting linked data */
996 SWIGINTERN int SWIG_Lua_module_set(lua_State* L)
997 {
998 /* there should be 3 params passed in
999  (1) table (not the meta table)
1000  (2) string name of the attribute
1001  (3) any for the new value
1002 */
1003  /* get the metatable */
1004 #if ((SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC))
1005  assert(lua_isrotable(L,1)); /* just in case */
1006 #else
1007  assert(lua_istable(L,1)); /* default Lua action */
1008 #endif
1009  lua_getmetatable(L,1); /* get the metatable */
1010 #if ((SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC))
1011  assert(lua_isrotable(L,-1)); /* just in case */
1012 #else
1013  assert(lua_istable(L,-1));
1014 #endif
1015  SWIG_Lua_get_table(L,".set"); /* get the .set table */
1016  lua_remove(L,4); /* remove metatable */
1017 #if ((SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC))
1018  if (lua_isrotable(L,-1))
1019 #else
1020  if (lua_istable(L,-1))
1021 #endif
1022  {
1023  /* look for the key in the .set table */
1024  lua_pushvalue(L,2); /* key */
1025  lua_rawget(L,-2);
1026  lua_remove(L,4); /* remove .set */
1027  if (lua_iscfunction(L,-1))
1028  { /* found it so call the fn & return its value */
1029  lua_pushvalue(L,3); /* value */
1030  lua_call(L,1,0);
1031  return 0;
1032  }
1033 #if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA)
1034  else {
1035  return 0; // Exits stoically if an invalid key is initialized.
1036  }
1037 #endif
1038  }
1039  lua_settop(L,3); /* reset back to start */
1040  /* we now have the table, key & new value, so just set directly */
1041  lua_rawset(L,1); /* add direct */
1042  return 0;
1043 }
1044 
1045 #if ((SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUA) && (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC))
1046 /* registering a module in lua. Pushes the module table on the stack. */
1047 SWIGINTERN void SWIG_Lua_module_begin(lua_State* L,const char* name)
1048 {
1049  assert(lua_istable(L,-1)); /* just in case */
1050  lua_pushstring(L,name);
1051  lua_newtable(L); /* the table */
1052  /* add meta table */
1053  lua_newtable(L); /* the meta table */
1054  SWIG_Lua_add_function(L,"__index",SWIG_Lua_module_get);
1055  SWIG_Lua_add_function(L,"__newindex",SWIG_Lua_module_set);
1056  lua_pushstring(L,".get");
1057  lua_newtable(L); /* the .get table */
1058  lua_rawset(L,-3); /* add .get into metatable */
1059  lua_pushstring(L,".set");
1060  lua_newtable(L); /* the .set table */
1061  lua_rawset(L,-3); /* add .set into metatable */
1062  lua_setmetatable(L,-2); /* sets meta table in module */
1063 #ifdef SWIG_LUA_MODULE_GLOBAL
1064  /* If requested, install the module directly into the global namespace. */
1065  lua_rawset(L,-3); /* add module into parent */
1066  SWIG_Lua_get_table(L,name); /* get the table back out */
1067 #else
1068  /* Do not install the module table as global name. The stack top has
1069  the module table with the name below. We pop the top and replace
1070  the name with it. */
1071  lua_replace(L,-2);
1072 #endif
1073 }
1074 
1075 /* ending the register */
1076 SWIGINTERN void SWIG_Lua_module_end(lua_State* L)
1077 {
1078  lua_pop(L,1); /* tidy stack (remove module) */
1079 }
1080 
1081 /* adding a linked variable to the module */
1082 SWIGINTERN void SWIG_Lua_module_add_variable(lua_State* L,const char* name,lua_CFunction getFn,lua_CFunction setFn)
1083 {
1084  assert(lua_istable(L,-1)); /* just in case */
1085  lua_getmetatable(L,-1); /* get the metatable */
1086  assert(lua_istable(L,-1)); /* just in case */
1087  SWIG_Lua_get_table(L,".get"); /* find the .get table */
1088  assert(lua_istable(L,-1)); /* should be a table: */
1089  SWIG_Lua_add_function(L,name,getFn);
1090  lua_pop(L,1); /* tidy stack (remove table) */
1091  if (setFn) /* if there is a set fn */
1092  {
1093  SWIG_Lua_get_table(L,".set"); /* find the .set table */
1094  assert(lua_istable(L,-1)); /* should be a table: */
1095  SWIG_Lua_add_function(L,name,setFn);
1096  lua_pop(L,1); /* tidy stack (remove table) */
1097  }
1098  lua_pop(L,1); /* tidy stack (remove meta) */
1099 }
1100 #endif
1101 
1102 /* adding a function module */
1103 SWIGINTERN void SWIG_Lua_module_add_function(lua_State* L,const char* name,lua_CFunction fn)
1104 {
1105  SWIG_Lua_add_function(L,name,fn);
1106 }
1107 
1108 /* -----------------------------------------------------------------------------
1109  * global variable support code: classes
1110  * ----------------------------------------------------------------------------- */
1111 
1112 /* the class.get method, performs the lookup of class attributes */
1113 SWIGINTERN int SWIG_Lua_class_get(lua_State* L)
1114 {
1115 /* there should be 2 params passed in
1116  (1) userdata (not the meta table)
1117  (2) string name of the attribute
1118 */
1119  assert(lua_isuserdata(L,-2)); /* just in case */
1120  lua_getmetatable(L,-2); /* get the meta table */
1121  assert(lua_istable(L,-1)); /* just in case */
1122  SWIG_Lua_get_table(L,".get"); /* find the .get table */
1123  assert(lua_istable(L,-1)); /* just in case */
1124  /* look for the key in the .get table */
1125  lua_pushvalue(L,2); /* key */
1126  lua_rawget(L,-2);
1127  lua_remove(L,-2); /* stack tidy, remove .get table */
1128  if (lua_iscfunction(L,-1))
1129  { /* found it so call the fn & return its value */
1130  lua_pushvalue(L,1); /* the userdata */
1131  lua_call(L,1,1); /* 1 value in (userdata),1 out (result) */
1132  lua_remove(L,-2); /* stack tidy, remove metatable */
1133  return 1;
1134  }
1135  lua_pop(L,1); /* remove whatever was there */
1136  /* ok, so try the .fn table */
1137  SWIG_Lua_get_table(L,".fn"); /* find the .get table */
1138  assert(lua_istable(L,-1)); /* just in case */
1139  lua_pushvalue(L,2); /* key */
1140  lua_rawget(L,-2); /* look for the fn */
1141  lua_remove(L,-2); /* stack tidy, remove .fn table */
1142  if (lua_isfunction(L,-1)) /* note: if its a C function or lua function */
1143  { /* found it so return the fn & let lua call it */
1144  lua_remove(L,-2); /* stack tidy, remove metatable */
1145  return 1;
1146  }
1147  lua_pop(L,1); /* remove whatever was there */
1148  /* NEW: looks for the __getitem() fn
1149  this is a user provided get fn */
1150  SWIG_Lua_get_table(L,"__getitem"); /* find the __getitem fn */
1151  if (lua_iscfunction(L,-1)) /* if its there */
1152  { /* found it so call the fn & return its value */
1153  lua_pushvalue(L,1); /* the userdata */
1154  lua_pushvalue(L,2); /* the parameter */
1155  lua_call(L,2,1); /* 2 value in (userdata),1 out (result) */
1156  lua_remove(L,-2); /* stack tidy, remove metatable */
1157  return 1;
1158  }
1159  return 0; /* sorry not known */
1160 }
1161 
1162 /* the class.set method, performs the lookup of class attributes */
1163 SWIGINTERN int SWIG_Lua_class_set(lua_State* L)
1164 {
1165 /* there should be 3 params passed in
1166  (1) table (not the meta table)
1167  (2) string name of the attribute
1168  (3) any for the new value
1169 printf("SWIG_Lua_class_set %p(%s) '%s' %p(%s)\n",
1170  lua_topointer(L,1),lua_typename(L,lua_type(L,1)),
1171  lua_tostring(L,2),
1172  lua_topointer(L,3),lua_typename(L,lua_type(L,3)));*/
1173 
1174  assert(lua_isuserdata(L,1)); /* just in case */
1175  lua_getmetatable(L,1); /* get the meta table */
1176  assert(lua_istable(L,-1)); /* just in case */
1177 
1178  SWIG_Lua_get_table(L,".set"); /* find the .set table */
1179  if (lua_istable(L,-1))
1180  {
1181  /* look for the key in the .set table */
1182  lua_pushvalue(L,2); /* key */
1183  lua_rawget(L,-2);
1184  if (lua_iscfunction(L,-1))
1185  { /* found it so call the fn & return its value */
1186  lua_pushvalue(L,1); /* userdata */
1187  lua_pushvalue(L,3); /* value */
1188  lua_call(L,2,0);
1189  return 0;
1190  }
1191  lua_pop(L,1); /* remove the value */
1192  }
1193  lua_pop(L,1); /* remove the value .set table */
1194  /* NEW: looks for the __setitem() fn
1195  this is a user provided set fn */
1196  SWIG_Lua_get_table(L,"__setitem"); /* find the fn */
1197  if (lua_iscfunction(L,-1)) /* if its there */
1198  { /* found it so call the fn & return its value */
1199  lua_pushvalue(L,1); /* the userdata */
1200  lua_pushvalue(L,2); /* the parameter */
1201  lua_pushvalue(L,3); /* the value */
1202  lua_call(L,3,0); /* 3 values in ,0 out */
1203  lua_remove(L,-2); /* stack tidy, remove metatable */
1204  return 1;
1205  }
1206  return 0;
1207 }
1208 
1209 /* the class.destruct method called by the interpreter */
1210 SWIGINTERN int SWIG_Lua_class_destruct(lua_State* L)
1211 {
1212 /* there should be 1 params passed in
1213  (1) userdata (not the meta table) */
1214  swig_lua_userdata* usr;
1215  swig_lua_class* clss;
1216  assert(lua_isuserdata(L,-1)); /* just in case */
1217  usr=(swig_lua_userdata*)lua_touserdata(L,-1); /* get it */
1218  /* if must be destroyed & has a destructor */
1219  if (usr->own) /* if must be destroyed */
1220  {
1221  clss=(swig_lua_class*)usr->type->clientdata; /* get the class */
1222  if (clss && clss->destructor) /* there is a destroy fn */
1223  {
1224  clss->destructor(usr->ptr); /* bye bye */
1225  }
1226  }
1227  return 0;
1228 }
1229 
1230 /* the class.__tostring method called by the interpreter and print */
1231 SWIGINTERN int SWIG_Lua_class_tostring(lua_State* L)
1232 {
1233 /* there should be 1 param passed in
1234  (1) userdata (not the metatable) */
1235  assert(lua_isuserdata(L,1)); /* just in case */
1236  unsigned long userData = (unsigned long)lua_touserdata(L,1); /* get the userdata address for later */
1237  lua_getmetatable(L,1); /* get the meta table */
1238  assert(lua_istable(L,-1)); /* just in case */
1239 
1240  lua_getfield(L, -1, ".type");
1241  const char* className = lua_tostring(L, -1);
1242 
1243  char output[256];
1244  sprintf(output, "<%s userdata: %lX>", className, userData);
1245 
1246  lua_pushstring(L, (const char*)output);
1247  return 1;
1248 }
1249 
1250 /* to manually disown some userdata */
1251 SWIGINTERN int SWIG_Lua_class_disown(lua_State* L)
1252 {
1253 /* there should be 1 params passed in
1254  (1) userdata (not the meta table) */
1255  swig_lua_userdata* usr;
1256  assert(lua_isuserdata(L,-1)); /* just in case */
1257  usr=(swig_lua_userdata*)lua_touserdata(L,-1); /* get it */
1258 
1259  usr->own = 0; /* clear our ownership */
1260  return 0;
1261 }
1262 
1263 /* gets the swig class registry (or creates it) */
1264 SWIGINTERN void SWIG_Lua_get_class_registry(lua_State* L)
1265 {
1266  /* add this all into the swig registry: */
1267  lua_pushstring(L,"SWIG");
1268  lua_rawget(L,LUA_REGISTRYINDEX); /* get the registry */
1269  if (!lua_istable(L,-1)) /* not there */
1270  { /* must be first time, so add it */
1271  lua_pop(L,1); /* remove the result */
1272  lua_pushstring(L,"SWIG");
1273  lua_newtable(L);
1274  lua_rawset(L,LUA_REGISTRYINDEX);
1275  /* then get it */
1276  lua_pushstring(L,"SWIG");
1277  lua_rawget(L,LUA_REGISTRYINDEX);
1278  }
1279 }
1280 
1281 /* helper fn to get the classes metatable from the register */
1282 SWIGINTERN void SWIG_Lua_get_class_metatable(lua_State* L,const char* cname)
1283 {
1284  SWIG_Lua_get_class_registry(L); /* get the registry */
1285  lua_pushstring(L,cname); /* get the name */
1286  lua_rawget(L,-2); /* get it */
1287  lua_remove(L,-2); /* tidy up (remove registry) */
1288 }
1289 
1290 /* helper add a variable to a registered class */
1291 SWIGINTERN void SWIG_Lua_add_class_variable(lua_State* L,const char* name,lua_CFunction getFn,lua_CFunction setFn)
1292 {
1293  assert(lua_istable(L,-1)); /* just in case */
1294  SWIG_Lua_get_table(L,".get"); /* find the .get table */
1295  assert(lua_istable(L,-1)); /* just in case */
1296  SWIG_Lua_add_function(L,name,getFn);
1297  lua_pop(L,1); /* tidy stack (remove table) */
1298  if (setFn)
1299  {
1300  SWIG_Lua_get_table(L,".set"); /* find the .set table */
1301  assert(lua_istable(L,-1)); /* just in case */
1302  SWIG_Lua_add_function(L,name,setFn);
1303  lua_pop(L,1); /* tidy stack (remove table) */
1304  }
1305 }
1306 
1307 /* helper to recursively add class details (attributes & operations) */
1308 SWIGINTERN void SWIG_Lua_add_class_details(lua_State* L,swig_lua_class* clss)
1309 {
1310  int i;
1311  /* call all the base classes first: we can then override these later: */
1312  for(i=0;clss->bases[i];i++)
1313  {
1314  SWIG_Lua_add_class_details(L,clss->bases[i]);
1315  }
1316  /* add fns */
1317  for(i=0;clss->attributes[i].name;i++){
1318  SWIG_Lua_add_class_variable(L,clss->attributes[i].name,clss->attributes[i].getmethod,clss->attributes[i].setmethod);
1319  }
1320  /* add methods to the metatable */
1321  SWIG_Lua_get_table(L,".fn"); /* find the .fn table */
1322  assert(lua_istable(L,-1)); /* just in case */
1323  for(i=0;clss->methods[i].name;i++){
1324  SWIG_Lua_add_function(L,clss->methods[i].name,clss->methods[i].method);
1325  }
1326  lua_pop(L,1); /* tidy stack (remove table) */
1327  /* add operator overloads
1328  these look ANY method which start with "__" and assume they
1329  are operator overloads & add them to the metatable
1330  (this might mess up is someone defines a method __gc (the destructor)*/
1331  for(i=0;clss->methods[i].name;i++){
1332  if (clss->methods[i].name[0]=='_' && clss->methods[i].name[1]=='_'){
1333  SWIG_Lua_add_function(L,clss->methods[i].name,clss->methods[i].method);
1334  }
1335  }
1336 }
1337 
1338 /* set up the base classes pointers.
1339 Each class structure has a list of pointers to the base class structures.
1340 This function fills them.
1341 It cannot be done at compile time, as this will not work with hireachies
1342 spread over more than one swig file.
1343 Therefore it must be done at runtime, querying the SWIG type system.
1344 */
1345 SWIGINTERN void SWIG_Lua_init_base_class(lua_State* L,swig_lua_class* clss)
1346 {
1347  int i=0;
1348  swig_module_info* module=SWIG_GetModule(L);
1349  for(i=0;clss->base_names[i];i++)
1350  {
1351  if (clss->bases[i]==0) /* not found yet */
1352  {
1353  /* lookup and cache the base class */
1354  swig_type_info *info = SWIG_TypeQueryModule(module,module,clss->base_names[i]);
1355  if (info) clss->bases[i] = (swig_lua_class *) info->clientdata;
1356  }
1357  }
1358 }
1359 
1360 /* performs the entire class registration process */
1361 SWIGINTERN void SWIG_Lua_class_register(lua_State* L,swig_lua_class* clss)
1362 {
1363  /* add its constructor to module with the name of the class
1364  so you can do MyClass(...) as well as new_MyClass(...)
1365  BUT only if a constructor is defined
1366  (this overcomes the problem of pure virtual classes without constructors)*/
1367  if (clss->constructor)
1368  SWIG_Lua_add_function(L,clss->name,clss->constructor);
1369 
1370  SWIG_Lua_get_class_registry(L); /* get the registry */
1371  lua_pushstring(L,clss->name); /* get the name */
1372  lua_newtable(L); /* create the metatable */
1373  /* add string of class name called ".type" */
1374  lua_pushstring(L,".type");
1375  lua_pushstring(L,clss->name);
1376  lua_rawset(L,-3);
1377  /* add a table called ".get" */
1378  lua_pushstring(L,".get");
1379  lua_newtable(L);
1380  lua_rawset(L,-3);
1381  /* add a table called ".set" */
1382  lua_pushstring(L,".set");
1383  lua_newtable(L);
1384  lua_rawset(L,-3);
1385  /* add a table called ".fn" */
1386  lua_pushstring(L,".fn");
1387  lua_newtable(L);
1388  /* add manual disown method */
1389  SWIG_Lua_add_function(L,"__disown",SWIG_Lua_class_disown);
1390  lua_rawset(L,-3);
1391  /* add accessor fns for using the .get,.set&.fn */
1392  SWIG_Lua_add_function(L,"__index",SWIG_Lua_class_get);
1393  SWIG_Lua_add_function(L,"__newindex",SWIG_Lua_class_set);
1394  SWIG_Lua_add_function(L,"__gc",SWIG_Lua_class_destruct);
1395  /* add tostring method for better output */
1396  SWIG_Lua_add_function(L,"__tostring",SWIG_Lua_class_tostring);
1397  /* add it */
1398  lua_rawset(L,-3); /* metatable into registry */
1399  lua_pop(L,1); /* tidy stack (remove registry) */
1400 
1401  SWIG_Lua_get_class_metatable(L,clss->name);
1402  SWIG_Lua_add_class_details(L,clss); /* recursive adding of details (atts & ops) */
1403  lua_pop(L,1); /* tidy stack (remove class metatable) */
1404 }
1405 
1406 /* -----------------------------------------------------------------------------
1407  * Class/structure conversion fns
1408  * ----------------------------------------------------------------------------- */
1409 
1410 /* helper to add metatable to new lua object */
1411 SWIGINTERN void _SWIG_Lua_AddMetatable(lua_State* L,swig_type_info *type)
1412 {
1413  if (type->clientdata) /* there is clientdata: so add the metatable */
1414  {
1415  SWIG_Lua_get_class_metatable(L,((swig_lua_class*)(type->clientdata))->name);
1416  if (lua_istable(L,-1))
1417  {
1418  lua_setmetatable(L,-2);
1419  }
1420  else
1421  {
1422  lua_pop(L,1);
1423  }
1424  }
1425 }
1426 
1427 /* pushes a new object into the lua stack */
1428 SWIGRUNTIME void SWIG_Lua_NewPointerObj(lua_State* L,void* ptr,swig_type_info *type, int own)
1429 {
1430  swig_lua_userdata* usr;
1431  if (!ptr){
1432  lua_pushnil(L);
1433  return;
1434  }
1435  usr=(swig_lua_userdata*)lua_newuserdata(L,sizeof(swig_lua_userdata)); /* get data */
1436  usr->ptr=ptr; /* set the ptr */
1437  usr->type=type;
1438  usr->own=own;
1439 #if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC)
1440  _SWIG_Lua_AddMetatable(L,type); /* add metatable */
1441 #endif
1442 }
1443 
1444 /* takes a object from the lua stack & converts it into an object of the correct type
1445  (if possible) */
1446 SWIGRUNTIME int SWIG_Lua_ConvertPtr(lua_State* L,int index,void** ptr,swig_type_info *type,int flags)
1447 {
1448  swig_lua_userdata* usr;
1449  swig_cast_info *cast;
1450  if (lua_isnil(L,index)){*ptr=0; return SWIG_OK;} /* special case: lua nil => NULL pointer */
1451  usr=(swig_lua_userdata*)lua_touserdata(L,index); /* get data */
1452  if (usr)
1453  {
1454  if (flags & SWIG_POINTER_DISOWN) /* must disown the object */
1455  {
1456  usr->own=0;
1457  }
1458  if (!type) /* special cast void*, no casting fn */
1459  {
1460  *ptr=usr->ptr;
1461  return SWIG_OK; /* ok */
1462  }
1463  cast=SWIG_TypeCheckStruct(usr->type,type); /* performs normal type checking */
1464  if (cast)
1465  {
1466  int newmemory = 0;
1467  *ptr=SWIG_TypeCast(cast,usr->ptr,&newmemory);
1468  assert(!newmemory); /* newmemory handling not yet implemented */
1469  return SWIG_OK; /* ok */
1470  }
1471  }
1472  return SWIG_ERROR; /* error */
1473 }
1474 
1475 SWIGRUNTIME void* SWIG_Lua_MustGetPtr(lua_State* L,int index,swig_type_info *type,int flags,
1476  int argnum,const char* func_name){
1477  void* result;
1478  if (!SWIG_IsOK(SWIG_ConvertPtr(L,index,&result,type,flags))){
1479  lua_pushfstring(L,"Error in %s, expected a %s at argument number %d\n",
1480  func_name,(type && type->str)?type->str:"void*",argnum);
1481  lua_error(L);
1482  }
1483  return result;
1484 }
1485 
1486 /* pushes a packed userdata. user for member fn pointers only */
1487 SWIGRUNTIME void SWIG_Lua_NewPackedObj(lua_State* L,void* ptr,size_t size,swig_type_info *type)
1488 {
1489  swig_lua_rawdata* raw;
1490  assert(ptr); /* not acceptable to pass in a NULL value */
1491  raw=(swig_lua_rawdata*)lua_newuserdata(L,sizeof(swig_lua_rawdata)-1+size); /* alloc data */
1492  raw->type=type;
1493  raw->own=0;
1494  memcpy(raw->data,ptr,size); /* copy the data */
1495  _SWIG_Lua_AddMetatable(L,type); /* add metatable */
1496 }
1497 
1498 /* converts a packed userdata. user for member fn pointers only */
1499 SWIGRUNTIME int SWIG_Lua_ConvertPacked(lua_State* L,int index,void* ptr,size_t size,swig_type_info *type)
1500 {
1501  swig_lua_rawdata* raw;
1502  raw=(swig_lua_rawdata*)lua_touserdata(L,index); /* get data */
1503  if (!raw) return SWIG_ERROR; /* error */
1504  if (type==0 || type==raw->type) /* void* or identical type */
1505  {
1506  memcpy(ptr,raw->data,size); /* copy it */
1507  return SWIG_OK; /* ok */
1508  }
1509  return SWIG_ERROR; /* error */
1510 }
1511 
1512 /* a function to get the typestring of a piece of data */
1513 SWIGRUNTIME const char *SWIG_Lua_typename(lua_State *L, int tp)
1514 {
1515  swig_lua_userdata* usr;
1516  if (lua_isuserdata(L,tp))
1517  {
1518  usr=(swig_lua_userdata*)lua_touserdata(L,tp); /* get data */
1519  if (usr && usr->type && usr->type->str)
1520  return usr->type->str;
1521  return "userdata (unknown type)";
1522  }
1523  return lua_typename(L,lua_type(L,tp));
1524 }
1525 
1526 /* lua callable function to get the userdata's type */
1527 SWIGRUNTIME int SWIG_Lua_type(lua_State* L)
1528 {
1529  lua_pushstring(L,SWIG_Lua_typename(L,1));
1530  return 1;
1531 }
1532 
1533 /* lua callable function to compare userdata's value
1534 the issue is that two userdata may point to the same thing
1535 but to lua, they are different objects */
1536 SWIGRUNTIME int SWIG_Lua_equal(lua_State* L)
1537 {
1538  int result;
1539  swig_lua_userdata *usr1,*usr2;
1540  if (!lua_isuserdata(L,1) || !lua_isuserdata(L,2)) /* just in case */
1541  return 0; /* nil reply */
1542  usr1=(swig_lua_userdata*)lua_touserdata(L,1); /* get data */
1543  usr2=(swig_lua_userdata*)lua_touserdata(L,2); /* get data */
1544  /*result=(usr1->ptr==usr2->ptr && usr1->type==usr2->type); only works if type is the same*/
1545  result=(usr1->ptr==usr2->ptr);
1546  lua_pushboolean(L,result);
1547  return 1;
1548 }
1549 
1550 /* -----------------------------------------------------------------------------
1551  * global variable support code: class/struct typemap functions
1552  * ----------------------------------------------------------------------------- */
1553 
1554 #if ((SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUA) && (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC))
1555 /* Install Constants */
1556 SWIGINTERN void
1557 SWIG_Lua_InstallConstants(lua_State* L, swig_lua_const_info constants[]) {
1558  int i;
1559  for (i = 0; constants[i].type; i++) {
1560  switch(constants[i].type) {
1561  case SWIG_LUA_INT:
1562  lua_pushstring(L,constants[i].name);
1563  lua_pushnumber(L,(lua_Number)constants[i].lvalue);
1564  lua_rawset(L,-3);
1565  break;
1566  case SWIG_LUA_FLOAT:
1567  lua_pushstring(L,constants[i].name);
1568  lua_pushnumber(L,(lua_Number)constants[i].dvalue);
1569  lua_rawset(L,-3);
1570  break;
1571  case SWIG_LUA_CHAR:
1572  lua_pushstring(L,constants[i].name);
1573  lua_pushfstring(L,"%c",(char)constants[i].lvalue);
1574  lua_rawset(L,-3);
1575  break;
1576  case SWIG_LUA_STRING:
1577  lua_pushstring(L,constants[i].name);
1578  lua_pushstring(L,(char *) constants[i].pvalue);
1579  lua_rawset(L,-3);
1580  break;
1581  case SWIG_LUA_POINTER:
1582  lua_pushstring(L,constants[i].name);
1583  SWIG_NewPointerObj(L,constants[i].pvalue, *(constants[i]).ptype,0);
1584  lua_rawset(L,-3);
1585  break;
1586  case SWIG_LUA_BINARY:
1587  lua_pushstring(L,constants[i].name);
1588  SWIG_NewMemberObj(L,constants[i].pvalue,constants[i].lvalue,*(constants[i]).ptype);
1589  lua_rawset(L,-3);
1590  break;
1591  default:
1592  break;
1593  }
1594  }
1595 }
1596 #endif
1597 
1598 /* -----------------------------------------------------------------------------
1599  * executing lua code from within the wrapper
1600  * ----------------------------------------------------------------------------- */
1601 
1602 #ifndef SWIG_DOSTRING_FAIL /* Allows redefining of error function */
1603 #define SWIG_DOSTRING_FAIL(S) fprintf(stderr,"%s\n",S)
1604 #endif
1605 /* Executes a C string in Lua which is a really simple way of calling lua from C
1606 Unfortunately lua keeps changing its APIs, so we need a conditional compile
1607 In lua 5.0.X its lua_dostring()
1608 In lua 5.1.X its luaL_dostring()
1609 */
1610 SWIGINTERN int
1611 SWIG_Lua_dostring(lua_State *L, const char* str) {
1612  int ok,top;
1613  if (str==0 || str[0]==0) return 0; /* nothing to do */
1614  top=lua_gettop(L); /* save stack */
1615 #if (defined(LUA_VERSION_NUM) && (LUA_VERSION_NUM>=501))
1616  ok=luaL_dostring(L,str); /* looks like this is lua 5.1.X or later, good */
1617 #else
1618  ok=lua_dostring(L,str); /* might be lua 5.0.x, using lua_dostring */
1619 #endif
1620  if (ok!=0) {
1621  SWIG_DOSTRING_FAIL(lua_tostring(L,-1));
1622  }
1623  lua_settop(L,top); /* restore the stack */
1624  return ok;
1625 }
1626 
1627 #ifdef __cplusplus
1628 }
1629 #endif
1630 
1631 /* ------------------------------ end luarun.swg ------------------------------ */
1632 
1633 /* Errors in SWIG */
1634 #define SWIG_UnknownError -1
1635 #define SWIG_IOError -2
1636 #define SWIG_RuntimeError -3
1637 #define SWIG_IndexError -4
1638 #define SWIG_TypeError -5
1639 #define SWIG_DivisionByZero -6
1640 #define SWIG_OverflowError -7
1641 #define SWIG_SyntaxError -8
1642 #define SWIG_ValueError -9
1643 #define SWIG_SystemError -10
1644 #define SWIG_AttributeError -11
1645 #define SWIG_MemoryError -12
1646 #define SWIG_NullReferenceError -13
1647 
1648 
1649 
1650 
1651 /* -------- TYPES TABLE (BEGIN) -------- */
1652 
1653 #define SWIGTYPE_p_Mezzanine__Threading__RawFile swig_types[0]
1654 #define SWIGTYPE_p_Mezzanine__Vector3 swig_types[1]
1655 #define SWIGTYPE_p_Mezzanine__XML__Attribute swig_types[2]
1656 #define SWIGTYPE_p_Mezzanine__XML__AttributeIterator swig_types[3]
1657 #define SWIGTYPE_p_Mezzanine__XML__AttributeStruct swig_types[4]
1658 #define SWIGTYPE_p_Mezzanine__XML__Document swig_types[5]
1659 #define SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator swig_types[6]
1660 #define SWIGTYPE_p_Mezzanine__XML__Node swig_types[7]
1661 #define SWIGTYPE_p_Mezzanine__XML__NodeIterator swig_types[8]
1662 #define SWIGTYPE_p_Mezzanine__XML__NodeStruct swig_types[9]
1663 #define SWIGTYPE_p_Mezzanine__XML__NodeText swig_types[10]
1664 #define SWIGTYPE_p_Mezzanine__XML__ObjectRangeT_Mezzanine__XML__AttributeIterator_t swig_types[11]
1665 #define SWIGTYPE_p_Mezzanine__XML__ObjectRangeT_Mezzanine__XML__NamedNodeIterator_t swig_types[12]
1666 #define SWIGTYPE_p_Mezzanine__XML__ObjectRangeT_Mezzanine__XML__NodeIterator_t swig_types[13]
1667 #define SWIGTYPE_p_Mezzanine__XML__ParseResult swig_types[14]
1668 #define SWIGTYPE_p_Mezzanine__XML__TreeWalker swig_types[15]
1669 #define SWIGTYPE_p_Mezzanine__XML__Writer swig_types[16]
1670 #define SWIGTYPE_p_Mezzanine__XML__WriterFile swig_types[17]
1671 #define SWIGTYPE_p_Mezzanine__XML__WriterStream swig_types[18]
1672 #define SWIGTYPE_p_Mezzanine__XML__XMLStreamWrapper swig_types[19]
1673 #define SWIGTYPE_p_Mezzanine__XML__XPathNode swig_types[20]
1674 #define SWIGTYPE_p_Mezzanine__XML__XPathNodeSet swig_types[21]
1675 #define SWIGTYPE_p_Mezzanine__XML__XPathParseResult swig_types[22]
1676 #define SWIGTYPE_p_Mezzanine__XML__XPathQuery swig_types[23]
1677 #define SWIGTYPE_p_Mezzanine__XML__XPathVariable swig_types[24]
1678 #define SWIGTYPE_p_Mezzanine__XML__XPathVariableSet swig_types[25]
1679 #define SWIGTYPE_p_Resource__DataStream swig_types[26]
1680 #define SWIGTYPE_p_SDL_Event swig_types[27]
1681 #define SWIGTYPE_p_attribute_iterator swig_types[28]
1682 #define SWIGTYPE_p_bool swig_types[29]
1683 #define SWIGTYPE_p_char swig_types[30]
1684 #define SWIGTYPE_p_difference_type swig_types[31]
1685 #define SWIGTYPE_p_double swig_types[32]
1686 #define SWIGTYPE_p_f_p_void__void swig_types[33]
1687 #define SWIGTYPE_p_f_size_t__p_void swig_types[34]
1688 #define SWIGTYPE_p_float swig_types[35]
1689 #define SWIGTYPE_p_int swig_types[36]
1690 #define SWIGTYPE_p_iterator swig_types[37]
1691 #define SWIGTYPE_p_iterator_category swig_types[38]
1692 #define SWIGTYPE_p_long_long swig_types[39]
1693 #define SWIGTYPE_p_ptrdiff_t swig_types[40]
1694 #define SWIGTYPE_p_short swig_types[41]
1695 #define SWIGTYPE_p_signed_char swig_types[42]
1696 #define SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t swig_types[43]
1697 #define SWIGTYPE_p_std__basic_istreamT_wchar_t_std__char_traitsT_wchar_t_t_t swig_types[44]
1698 #define SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t swig_types[45]
1699 #define SWIGTYPE_p_std__basic_ostreamT_wchar_t_std__char_traitsT_wchar_t_t_t swig_types[46]
1700 #define SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t swig_types[47]
1701 #define SWIGTYPE_p_std__basic_stringT_wchar_t_std__char_traitsT_wchar_t_t_std__allocatorT_wchar_t_t_t swig_types[48]
1702 #define SWIGTYPE_p_std__istream swig_types[49]
1703 #define SWIGTYPE_p_std__listT_std__pairT_std__string_std__string_t_t swig_types[50]
1704 #define SWIGTYPE_p_std__mapT_std__string_std__string_t swig_types[51]
1705 #define SWIGTYPE_p_std__pairT_std__string_std__string_t swig_types[52]
1706 #define SWIGTYPE_p_std__setT_std__string_t swig_types[53]
1707 #define SWIGTYPE_p_std__string swig_types[54]
1708 #define SWIGTYPE_p_std__stringstream swig_types[55]
1709 #define SWIGTYPE_p_std__vectorT_std__string_t swig_types[56]
1710 #define SWIGTYPE_p_std__wstring swig_types[57]
1711 #define SWIGTYPE_p_unsigned_char swig_types[58]
1712 #define SWIGTYPE_p_unsigned_int swig_types[59]
1713 #define SWIGTYPE_p_unsigned_long swig_types[60]
1714 #define SWIGTYPE_p_unsigned_long_long swig_types[61]
1715 #define SWIGTYPE_p_unsigned_short swig_types[62]
1716 #define SWIGTYPE_p_value_type swig_types[63]
1717 #define SWIGTYPE_p_wchar_t swig_types[64]
1718 static swig_type_info *swig_types[66];
1719 static swig_module_info swig_module = {swig_types, 65, 0, 0, 0, 0};
1720 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
1721 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
1722 
1723 /* -------- TYPES TABLE (END) -------- */
1724 
1725 #define SWIG_name "MezzanineXML"
1726 #define SWIG_init luaopen_MezzanineXML
1727 #define SWIG_init_user luaopen_MezzanineXML_user
1728 
1729 #define SWIG_LUACODE luaopen_MezzanineXML_luacode
1730 
1731 namespace swig {
1732 typedef struct{} LANGUAGE_OBJ;
1733 }
1734 
1735 
1736  // code to be inserted verbatim into the swig file goes here
1737  #include "mezzanine.h"
1738  #include "btBulletDynamicsCommon.h"
1739  #include "Ogre.h"
1740  #include "SDL.h"
1741 
1742  #ifdef GetCurrentTime
1743  #undef GetCurrentTime
1744  #endif
1745 
1746  #ifdef GetExceptionCode
1747  #undef GetExceptionCode
1748  #endif
1749 
1750  using namespace Mezzanine;
1751  //using namespace Mezzanine::Threading;
1752  //using namespace Mezzanine::Physics;
1753 
1754  // Fix cross module type-usage
1755  namespace Mezzanine
1756  {
1757  namespace Physics
1758  {
1759  typedef Mezzanine::Vector3 Vector3;
1760  }
1761  namespace Threading
1762  {
1763 
1764  }
1765  typedef Threading::RawFile RawFile;
1766  }
1767 
1768 
1769 #include <stdexcept>
1770 
1771 
1772 #define SWIG_exception(a,b)\
1773 { lua_pushfstring(L,"%s:%s",#a,b);SWIG_fail; }
1774 
1775 
1776 #include <stdexcept>
1777 
1778 
1779 #include <string>
1780 
1781 
1782 SWIGINTERN int SWIG_lua_isnilstring(lua_State *L, int idx) {
1783  int ret = lua_isstring(L, idx);
1784  if (!ret)
1785  ret = lua_isnil(L, idx);
1786  return ret;
1787 }
1788 
1789 
1790 #include <vector>
1791 
1792 
1793 #include <map>
1794 #include <algorithm>
1795 #include <stdexcept>
1796 
1797 
1798 #include <utility>
1799 
1800 
1801 #include <stdint.h> // Use the C99 official header
1802 
1803 
1804 #include <deque>
1805 #include <stdexcept>
1806 
1807 #ifdef __cplusplus
1808 extern "C" {
1809 #endif
1810 static int _wrap_new_string__SWIG_0(lua_State* L) {
1811  int SWIG_arg = 0;
1812  std::string *result = 0 ;
1813 
1814  SWIG_check_num_args("std::string::string",0,0)
1815  result = (std::string *)new std::string();
1816  SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__string,1); SWIG_arg++;
1817  return SWIG_arg;
1818 
1819  if(0) SWIG_fail;
1820 
1821 fail:
1822  lua_error(L);
1823  return SWIG_arg;
1824 }
1825 
1826 
1827 static int _wrap_new_string__SWIG_1(lua_State* L) {
1828  int SWIG_arg = 0;
1829  char *arg1 = (char *) 0 ;
1830  std::string *result = 0 ;
1831 
1832  SWIG_check_num_args("std::string::string",1,1)
1833  if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("std::string::string",1,"char const *");
1834  arg1 = (char *)lua_tostring(L, 1);
1835  result = (std::string *)new std::string((char const *)arg1);
1836  SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__string,1); SWIG_arg++;
1837  return SWIG_arg;
1838 
1839  if(0) SWIG_fail;
1840 
1841 fail:
1842  lua_error(L);
1843  return SWIG_arg;
1844 }
1845 
1846 
1847 static int _wrap_new_string(lua_State* L) {
1848  int argc;
1849  int argv[2]={
1850  1,2
1851  };
1852 
1853  argc = lua_gettop(L);
1854  if (argc == 0) {
1855  return _wrap_new_string__SWIG_0(L);
1856  }
1857  if (argc == 1) {
1858  int _v;
1859  {
1860  _v = SWIG_lua_isnilstring(L,argv[0]);
1861  }
1862  if (_v) {
1863  return _wrap_new_string__SWIG_1(L);
1864  }
1865  }
1866 
1867  lua_pushstring(L,"Wrong arguments for overloaded function 'new_string'\n"
1868  " Possible C/C++ prototypes are:\n"
1869  " std::string::string()\n"
1870  " std::string::string(char const *)\n");
1871  lua_error(L);return 0;
1872 }
1873 
1874 
1875 static int _wrap_string_size(lua_State* L) {
1876  int SWIG_arg = 0;
1877  std::string *arg1 = (std::string *) 0 ;
1878  unsigned int result;
1879 
1880  SWIG_check_num_args("std::string::size",1,1)
1881  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::size",1,"std::string const *");
1882 
1883  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){
1884  SWIG_fail_ptr("string_size",1,SWIGTYPE_p_std__string);
1885  }
1886 
1887  result = (unsigned int)((std::string const *)arg1)->size();
1888  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
1889  return SWIG_arg;
1890 
1891  if(0) SWIG_fail;
1892 
1893 fail:
1894  lua_error(L);
1895  return SWIG_arg;
1896 }
1897 
1898 
1899 static int _wrap_string_length(lua_State* L) {
1900  int SWIG_arg = 0;
1901  std::string *arg1 = (std::string *) 0 ;
1902  unsigned int result;
1903 
1904  SWIG_check_num_args("std::string::length",1,1)
1905  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::length",1,"std::string const *");
1906 
1907  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){
1908  SWIG_fail_ptr("string_length",1,SWIGTYPE_p_std__string);
1909  }
1910 
1911  result = (unsigned int)((std::string const *)arg1)->length();
1912  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
1913  return SWIG_arg;
1914 
1915  if(0) SWIG_fail;
1916 
1917 fail:
1918  lua_error(L);
1919  return SWIG_arg;
1920 }
1921 
1922 
1923 static int _wrap_string_empty(lua_State* L) {
1924  int SWIG_arg = 0;
1925  std::string *arg1 = (std::string *) 0 ;
1926  bool result;
1927 
1928  SWIG_check_num_args("std::string::empty",1,1)
1929  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::empty",1,"std::string const *");
1930 
1931  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){
1932  SWIG_fail_ptr("string_empty",1,SWIGTYPE_p_std__string);
1933  }
1934 
1935  result = (bool)((std::string const *)arg1)->empty();
1936  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
1937  return SWIG_arg;
1938 
1939  if(0) SWIG_fail;
1940 
1941 fail:
1942  lua_error(L);
1943  return SWIG_arg;
1944 }
1945 
1946 
1947 static int _wrap_string_c_str(lua_State* L) {
1948  int SWIG_arg = 0;
1949  std::string *arg1 = (std::string *) 0 ;
1950  char *result = 0 ;
1951 
1952  SWIG_check_num_args("std::string::c_str",1,1)
1953  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::c_str",1,"std::string const *");
1954 
1955  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){
1956  SWIG_fail_ptr("string_c_str",1,SWIGTYPE_p_std__string);
1957  }
1958 
1959  result = (char *)((std::string const *)arg1)->c_str();
1960  lua_pushstring(L,(const char *)result); SWIG_arg++;
1961  return SWIG_arg;
1962 
1963  if(0) SWIG_fail;
1964 
1965 fail:
1966  lua_error(L);
1967  return SWIG_arg;
1968 }
1969 
1970 
1971 static int _wrap_string_data(lua_State* L) {
1972  int SWIG_arg = 0;
1973  std::string *arg1 = (std::string *) 0 ;
1974  char *result = 0 ;
1975 
1976  SWIG_check_num_args("std::string::data",1,1)
1977  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::data",1,"std::string const *");
1978 
1979  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){
1980  SWIG_fail_ptr("string_data",1,SWIGTYPE_p_std__string);
1981  }
1982 
1983  result = (char *)((std::string const *)arg1)->data();
1984  lua_pushstring(L,(const char *)result); SWIG_arg++;
1985  return SWIG_arg;
1986 
1987  if(0) SWIG_fail;
1988 
1989 fail:
1990  lua_error(L);
1991  return SWIG_arg;
1992 }
1993 
1994 
1995 static int _wrap_string_assign(lua_State* L) {
1996  int SWIG_arg = 0;
1997  std::string *arg1 = (std::string *) 0 ;
1998  char *arg2 = (char *) 0 ;
1999 
2000  SWIG_check_num_args("std::string::assign",2,2)
2001  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::assign",1,"std::string *");
2002  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("std::string::assign",2,"char const *");
2003 
2004  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){
2005  SWIG_fail_ptr("string_assign",1,SWIGTYPE_p_std__string);
2006  }
2007 
2008  arg2 = (char *)lua_tostring(L, 2);
2009  (arg1)->assign((char const *)arg2);
2010 
2011  return SWIG_arg;
2012 
2013  if(0) SWIG_fail;
2014 
2015 fail:
2016  lua_error(L);
2017  return SWIG_arg;
2018 }
2019 
2020 
2021 static void swig_delete_string(void *obj) {
2022 std::string *arg1 = (std::string *) obj;
2023 delete arg1;
2024 }
2025 static swig_lua_method swig_std_string_methods[] = {
2026  {"size", _wrap_string_size},
2027  {"length", _wrap_string_length},
2028  {"empty", _wrap_string_empty},
2029  {"c_str", _wrap_string_c_str},
2030  {"data", _wrap_string_data},
2031  {"assign", _wrap_string_assign},
2032  {0,0}
2033 };
2034 static swig_lua_attribute swig_std_string_attributes[] = {
2035  {0,0,0}
2036 };
2037 static swig_lua_class *swig_std_string_bases[] = {0};
2038 static const char *swig_std_string_base_names[] = {0};
2039 static swig_lua_class _wrap_class_std_string = { "string", &SWIGTYPE_p_std__string,_wrap_new_string, swig_delete_string, swig_std_string_methods, swig_std_string_attributes, swig_std_string_bases, swig_std_string_base_names };
2040 
2041 static int _wrap_new_Attribute__SWIG_0(lua_State* L) {
2042  int SWIG_arg = 0;
2043  Mezzanine::XML::Attribute *result = 0 ;
2044 
2045  SWIG_check_num_args("Mezzanine::XML::Attribute::Attribute",0,0)
2046  result = (Mezzanine::XML::Attribute *)new Mezzanine::XML::Attribute();
2047  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__XML__Attribute,1); SWIG_arg++;
2048  return SWIG_arg;
2049 
2050  if(0) SWIG_fail;
2051 
2052 fail:
2053  lua_error(L);
2054  return SWIG_arg;
2055 }
2056 
2057 
2058 static int _wrap_new_Attribute__SWIG_1(lua_State* L) {
2059  int SWIG_arg = 0;
2060  Mezzanine::XML::AttributeStruct *arg1 = (Mezzanine::XML::AttributeStruct *) 0 ;
2061  Mezzanine::XML::Attribute *result = 0 ;
2062 
2063  SWIG_check_num_args("Mezzanine::XML::Attribute::Attribute",1,1)
2064  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Attribute::Attribute",1,"Mezzanine::XML::AttributeStruct *");
2065 
2066  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__AttributeStruct,0))){
2067  SWIG_fail_ptr("new_Attribute",1,SWIGTYPE_p_Mezzanine__XML__AttributeStruct);
2068  }
2069 
2071  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__XML__Attribute,1); SWIG_arg++;
2072  return SWIG_arg;
2073 
2074  if(0) SWIG_fail;
2075 
2076 fail:
2077  lua_error(L);
2078  return SWIG_arg;
2079 }
2080 
2081 
2082 static int _wrap_new_Attribute(lua_State* L) {
2083  int argc;
2084  int argv[2]={
2085  1,2
2086  };
2087 
2088  argc = lua_gettop(L);
2089  if (argc == 0) {
2090  return _wrap_new_Attribute__SWIG_0(L);
2091  }
2092  if (argc == 1) {
2093  int _v;
2094  {
2095  void *ptr;
2096  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__AttributeStruct, 0)) {
2097  _v = 0;
2098  } else {
2099  _v = 1;
2100  }
2101  }
2102  if (_v) {
2103  return _wrap_new_Attribute__SWIG_1(L);
2104  }
2105  }
2106 
2107  lua_pushstring(L,"Wrong arguments for overloaded function 'new_Attribute'\n"
2108  " Possible C/C++ prototypes are:\n"
2109  " Mezzanine::XML::Attribute::Attribute()\n"
2110  " Mezzanine::XML::Attribute::Attribute(Mezzanine::XML::AttributeStruct *)\n");
2111  lua_error(L);return 0;
2112 }
2113 
2114 
2115 static int _wrap_Attribute___lt(lua_State* L) {
2116  int SWIG_arg = 0;
2118  Mezzanine::XML::Attribute *arg2 = 0 ;
2119  bool result;
2120 
2121  SWIG_check_num_args("Mezzanine::XML::Attribute::operator <",2,2)
2122  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Attribute::operator <",1,"Mezzanine::XML::Attribute const *");
2123  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Attribute::operator <",2,"Mezzanine::XML::Attribute const &");
2124 
2125  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
2126  SWIG_fail_ptr("Attribute___lt",1,SWIGTYPE_p_Mezzanine__XML__Attribute);
2127  }
2128 
2129 
2130  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
2131  SWIG_fail_ptr("Attribute___lt",2,SWIGTYPE_p_Mezzanine__XML__Attribute);
2132  }
2133 
2134  result = (bool)((Mezzanine::XML::Attribute const *)arg1)->operator <((Mezzanine::XML::Attribute const &)*arg2);
2135  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
2136  return SWIG_arg;
2137 
2138  if(0) SWIG_fail;
2139 
2140 fail:
2141  lua_error(L);
2142  return SWIG_arg;
2143 }
2144 
2145 
2146 static int _wrap_Attribute___le(lua_State* L) {
2147  int SWIG_arg = 0;
2149  Mezzanine::XML::Attribute *arg2 = 0 ;
2150  bool result;
2151 
2152  SWIG_check_num_args("Mezzanine::XML::Attribute::operator <=",2,2)
2153  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Attribute::operator <=",1,"Mezzanine::XML::Attribute const *");
2154  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Attribute::operator <=",2,"Mezzanine::XML::Attribute const &");
2155 
2156  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
2157  SWIG_fail_ptr("Attribute___le",1,SWIGTYPE_p_Mezzanine__XML__Attribute);
2158  }
2159 
2160 
2161  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
2162  SWIG_fail_ptr("Attribute___le",2,SWIGTYPE_p_Mezzanine__XML__Attribute);
2163  }
2164 
2165  result = (bool)((Mezzanine::XML::Attribute const *)arg1)->operator <=((Mezzanine::XML::Attribute const &)*arg2);
2166  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
2167  return SWIG_arg;
2168 
2169  if(0) SWIG_fail;
2170 
2171 fail:
2172  lua_error(L);
2173  return SWIG_arg;
2174 }
2175 
2176 
2177 static int _wrap_Attribute_Empty(lua_State* L) {
2178  int SWIG_arg = 0;
2180  bool result;
2181 
2182  SWIG_check_num_args("Mezzanine::XML::Attribute::Empty",1,1)
2183  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Attribute::Empty",1,"Mezzanine::XML::Attribute const *");
2184 
2185  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
2186  SWIG_fail_ptr("Attribute_Empty",1,SWIGTYPE_p_Mezzanine__XML__Attribute);
2187  }
2188 
2189  result = (bool)((Mezzanine::XML::Attribute const *)arg1)->Empty();
2190  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
2191  return SWIG_arg;
2192 
2193  if(0) SWIG_fail;
2194 
2195 fail:
2196  lua_error(L);
2197  return SWIG_arg;
2198 }
2199 
2200 
2201 static int _wrap_Attribute_Name(lua_State* L) {
2202  int SWIG_arg = 0;
2204  Mezzanine::Char8 *result = 0 ;
2205 
2206  SWIG_check_num_args("Mezzanine::XML::Attribute::Name",1,1)
2207  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Attribute::Name",1,"Mezzanine::XML::Attribute const *");
2208 
2209  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
2210  SWIG_fail_ptr("Attribute_Name",1,SWIGTYPE_p_Mezzanine__XML__Attribute);
2211  }
2212 
2213  result = (Mezzanine::Char8 *)((Mezzanine::XML::Attribute const *)arg1)->Name();
2214  lua_pushstring(L,(const char *)result); SWIG_arg++;
2215  return SWIG_arg;
2216 
2217  if(0) SWIG_fail;
2218 
2219 fail:
2220  lua_error(L);
2221  return SWIG_arg;
2222 }
2223 
2224 
2225 static int _wrap_Attribute_Value(lua_State* L) {
2226  int SWIG_arg = 0;
2228  Mezzanine::Char8 *result = 0 ;
2229 
2230  SWIG_check_num_args("Mezzanine::XML::Attribute::Value",1,1)
2231  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Attribute::Value",1,"Mezzanine::XML::Attribute const *");
2232 
2233  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
2234  SWIG_fail_ptr("Attribute_Value",1,SWIGTYPE_p_Mezzanine__XML__Attribute);
2235  }
2236 
2237  result = (Mezzanine::Char8 *)((Mezzanine::XML::Attribute const *)arg1)->Value();
2238  lua_pushstring(L,(const char *)result); SWIG_arg++;
2239  return SWIG_arg;
2240 
2241  if(0) SWIG_fail;
2242 
2243 fail:
2244  lua_error(L);
2245  return SWIG_arg;
2246 }
2247 
2248 
2249 static int _wrap_Attribute_AsString__SWIG_0(lua_State* L) {
2250  int SWIG_arg = 0;
2252  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
2253  Mezzanine::Char8 *result = 0 ;
2254 
2255  SWIG_check_num_args("Mezzanine::XML::Attribute::AsString",2,2)
2256  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Attribute::AsString",1,"Mezzanine::XML::Attribute const *");
2257  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Attribute::AsString",2,"Mezzanine::Char8 const *");
2258 
2259  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
2260  SWIG_fail_ptr("Attribute_AsString",1,SWIGTYPE_p_Mezzanine__XML__Attribute);
2261  }
2262 
2263  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
2264  result = (Mezzanine::Char8 *)((Mezzanine::XML::Attribute const *)arg1)->AsString((Mezzanine::Char8 const *)arg2);
2265  lua_pushstring(L,(const char *)result); SWIG_arg++;
2266  return SWIG_arg;
2267 
2268  if(0) SWIG_fail;
2269 
2270 fail:
2271  lua_error(L);
2272  return SWIG_arg;
2273 }
2274 
2275 
2276 static int _wrap_Attribute_AsString__SWIG_1(lua_State* L) {
2277  int SWIG_arg = 0;
2279  Mezzanine::Char8 *result = 0 ;
2280 
2281  SWIG_check_num_args("Mezzanine::XML::Attribute::AsString",1,1)
2282  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Attribute::AsString",1,"Mezzanine::XML::Attribute const *");
2283 
2284  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
2285  SWIG_fail_ptr("Attribute_AsString",1,SWIGTYPE_p_Mezzanine__XML__Attribute);
2286  }
2287 
2288  result = (Mezzanine::Char8 *)((Mezzanine::XML::Attribute const *)arg1)->AsString();
2289  lua_pushstring(L,(const char *)result); SWIG_arg++;
2290  return SWIG_arg;
2291 
2292  if(0) SWIG_fail;
2293 
2294 fail:
2295  lua_error(L);
2296  return SWIG_arg;
2297 }
2298 
2299 
2300 static int _wrap_Attribute_AsString(lua_State* L) {
2301  int argc;
2302  int argv[3]={
2303  1,2,3
2304  };
2305 
2306  argc = lua_gettop(L);
2307  if (argc == 1) {
2308  int _v;
2309  {
2310  void *ptr;
2311  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Attribute, 0)) {
2312  _v = 0;
2313  } else {
2314  _v = 1;
2315  }
2316  }
2317  if (_v) {
2318  return _wrap_Attribute_AsString__SWIG_1(L);
2319  }
2320  }
2321  if (argc == 2) {
2322  int _v;
2323  {
2324  void *ptr;
2325  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Attribute, 0)) {
2326  _v = 0;
2327  } else {
2328  _v = 1;
2329  }
2330  }
2331  if (_v) {
2332  {
2333  _v = SWIG_lua_isnilstring(L,argv[1]);
2334  }
2335  if (_v) {
2336  return _wrap_Attribute_AsString__SWIG_0(L);
2337  }
2338  }
2339  }
2340 
2341  lua_pushstring(L,"Wrong arguments for overloaded function 'Attribute_AsString'\n"
2342  " Possible C/C++ prototypes are:\n"
2343  " Mezzanine::XML::Attribute::AsString(Mezzanine::Char8 const *) const\n"
2344  " Mezzanine::XML::Attribute::AsString() const\n");
2345  lua_error(L);return 0;
2346 }
2347 
2348 
2349 static int _wrap_Attribute_AsInt__SWIG_0(lua_State* L) {
2350  int SWIG_arg = 0;
2352  int arg2 ;
2353  int result;
2354 
2355  SWIG_check_num_args("Mezzanine::XML::Attribute::AsInt",2,2)
2356  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Attribute::AsInt",1,"Mezzanine::XML::Attribute const *");
2357  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::XML::Attribute::AsInt",2,"int");
2358 
2359  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
2360  SWIG_fail_ptr("Attribute_AsInt",1,SWIGTYPE_p_Mezzanine__XML__Attribute);
2361  }
2362 
2363  arg2 = (int)lua_tonumber(L, 2);
2364  result = (int)((Mezzanine::XML::Attribute const *)arg1)->AsInt(arg2);
2365  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
2366  return SWIG_arg;
2367 
2368  if(0) SWIG_fail;
2369 
2370 fail:
2371  lua_error(L);
2372  return SWIG_arg;
2373 }
2374 
2375 
2376 static int _wrap_Attribute_AsInt__SWIG_1(lua_State* L) {
2377  int SWIG_arg = 0;
2379  int result;
2380 
2381  SWIG_check_num_args("Mezzanine::XML::Attribute::AsInt",1,1)
2382  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Attribute::AsInt",1,"Mezzanine::XML::Attribute const *");
2383 
2384  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
2385  SWIG_fail_ptr("Attribute_AsInt",1,SWIGTYPE_p_Mezzanine__XML__Attribute);
2386  }
2387 
2388  result = (int)((Mezzanine::XML::Attribute const *)arg1)->AsInt();
2389  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
2390  return SWIG_arg;
2391 
2392  if(0) SWIG_fail;
2393 
2394 fail:
2395  lua_error(L);
2396  return SWIG_arg;
2397 }
2398 
2399 
2400 static int _wrap_Attribute_AsInt(lua_State* L) {
2401  int argc;
2402  int argv[3]={
2403  1,2,3
2404  };
2405 
2406  argc = lua_gettop(L);
2407  if (argc == 1) {
2408  int _v;
2409  {
2410  void *ptr;
2411  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Attribute, 0)) {
2412  _v = 0;
2413  } else {
2414  _v = 1;
2415  }
2416  }
2417  if (_v) {
2418  return _wrap_Attribute_AsInt__SWIG_1(L);
2419  }
2420  }
2421  if (argc == 2) {
2422  int _v;
2423  {
2424  void *ptr;
2425  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Attribute, 0)) {
2426  _v = 0;
2427  } else {
2428  _v = 1;
2429  }
2430  }
2431  if (_v) {
2432  {
2433  _v = lua_isnumber(L,argv[1]);
2434  }
2435  if (_v) {
2436  return _wrap_Attribute_AsInt__SWIG_0(L);
2437  }
2438  }
2439  }
2440 
2441  lua_pushstring(L,"Wrong arguments for overloaded function 'Attribute_AsInt'\n"
2442  " Possible C/C++ prototypes are:\n"
2443  " Mezzanine::XML::Attribute::AsInt(int) const\n"
2444  " Mezzanine::XML::Attribute::AsInt() const\n");
2445  lua_error(L);return 0;
2446 }
2447 
2448 
2449 static int _wrap_Attribute_AsUint__SWIG_0(lua_State* L) {
2450  int SWIG_arg = 0;
2452  unsigned int arg2 ;
2453  unsigned int result;
2454 
2455  SWIG_check_num_args("Mezzanine::XML::Attribute::AsUint",2,2)
2456  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Attribute::AsUint",1,"Mezzanine::XML::Attribute const *");
2457  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::XML::Attribute::AsUint",2,"unsigned int");
2458 
2459  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
2460  SWIG_fail_ptr("Attribute_AsUint",1,SWIGTYPE_p_Mezzanine__XML__Attribute);
2461  }
2462 
2463  SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative")
2464  arg2 = (unsigned int)lua_tonumber(L, 2);
2465  result = (unsigned int)((Mezzanine::XML::Attribute const *)arg1)->AsUint(arg2);
2466  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
2467  return SWIG_arg;
2468 
2469  if(0) SWIG_fail;
2470 
2471 fail:
2472  lua_error(L);
2473  return SWIG_arg;
2474 }
2475 
2476 
2477 static int _wrap_Attribute_AsUint__SWIG_1(lua_State* L) {
2478  int SWIG_arg = 0;
2480  unsigned int result;
2481 
2482  SWIG_check_num_args("Mezzanine::XML::Attribute::AsUint",1,1)
2483  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Attribute::AsUint",1,"Mezzanine::XML::Attribute const *");
2484 
2485  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
2486  SWIG_fail_ptr("Attribute_AsUint",1,SWIGTYPE_p_Mezzanine__XML__Attribute);
2487  }
2488 
2489  result = (unsigned int)((Mezzanine::XML::Attribute const *)arg1)->AsUint();
2490  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
2491  return SWIG_arg;
2492 
2493  if(0) SWIG_fail;
2494 
2495 fail:
2496  lua_error(L);
2497  return SWIG_arg;
2498 }
2499 
2500 
2501 static int _wrap_Attribute_AsUint(lua_State* L) {
2502  int argc;
2503  int argv[3]={
2504  1,2,3
2505  };
2506 
2507  argc = lua_gettop(L);
2508  if (argc == 1) {
2509  int _v;
2510  {
2511  void *ptr;
2512  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Attribute, 0)) {
2513  _v = 0;
2514  } else {
2515  _v = 1;
2516  }
2517  }
2518  if (_v) {
2519  return _wrap_Attribute_AsUint__SWIG_1(L);
2520  }
2521  }
2522  if (argc == 2) {
2523  int _v;
2524  {
2525  void *ptr;
2526  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Attribute, 0)) {
2527  _v = 0;
2528  } else {
2529  _v = 1;
2530  }
2531  }
2532  if (_v) {
2533  {
2534  _v = lua_isnumber(L,argv[1]);
2535  }
2536  if (_v) {
2537  return _wrap_Attribute_AsUint__SWIG_0(L);
2538  }
2539  }
2540  }
2541 
2542  lua_pushstring(L,"Wrong arguments for overloaded function 'Attribute_AsUint'\n"
2543  " Possible C/C++ prototypes are:\n"
2544  " Mezzanine::XML::Attribute::AsUint(unsigned int) const\n"
2545  " Mezzanine::XML::Attribute::AsUint() const\n");
2546  lua_error(L);return 0;
2547 }
2548 
2549 
2550 static int _wrap_Attribute_AsDouble__SWIG_0(lua_State* L) {
2551  int SWIG_arg = 0;
2553  double arg2 ;
2554  double result;
2555 
2556  SWIG_check_num_args("Mezzanine::XML::Attribute::AsDouble",2,2)
2557  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Attribute::AsDouble",1,"Mezzanine::XML::Attribute const *");
2558  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::XML::Attribute::AsDouble",2,"double");
2559 
2560  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
2561  SWIG_fail_ptr("Attribute_AsDouble",1,SWIGTYPE_p_Mezzanine__XML__Attribute);
2562  }
2563 
2564  arg2 = (double)lua_tonumber(L, 2);
2565  result = (double)((Mezzanine::XML::Attribute const *)arg1)->AsDouble(arg2);
2566  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
2567  return SWIG_arg;
2568 
2569  if(0) SWIG_fail;
2570 
2571 fail:
2572  lua_error(L);
2573  return SWIG_arg;
2574 }
2575 
2576 
2577 static int _wrap_Attribute_AsDouble__SWIG_1(lua_State* L) {
2578  int SWIG_arg = 0;
2580  double result;
2581 
2582  SWIG_check_num_args("Mezzanine::XML::Attribute::AsDouble",1,1)
2583  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Attribute::AsDouble",1,"Mezzanine::XML::Attribute const *");
2584 
2585  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
2586  SWIG_fail_ptr("Attribute_AsDouble",1,SWIGTYPE_p_Mezzanine__XML__Attribute);
2587  }
2588 
2589  result = (double)((Mezzanine::XML::Attribute const *)arg1)->AsDouble();
2590  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
2591  return SWIG_arg;
2592 
2593  if(0) SWIG_fail;
2594 
2595 fail:
2596  lua_error(L);
2597  return SWIG_arg;
2598 }
2599 
2600 
2601 static int _wrap_Attribute_AsDouble(lua_State* L) {
2602  int argc;
2603  int argv[3]={
2604  1,2,3
2605  };
2606 
2607  argc = lua_gettop(L);
2608  if (argc == 1) {
2609  int _v;
2610  {
2611  void *ptr;
2612  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Attribute, 0)) {
2613  _v = 0;
2614  } else {
2615  _v = 1;
2616  }
2617  }
2618  if (_v) {
2619  return _wrap_Attribute_AsDouble__SWIG_1(L);
2620  }
2621  }
2622  if (argc == 2) {
2623  int _v;
2624  {
2625  void *ptr;
2626  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Attribute, 0)) {
2627  _v = 0;
2628  } else {
2629  _v = 1;
2630  }
2631  }
2632  if (_v) {
2633  {
2634  _v = lua_isnumber(L,argv[1]);
2635  }
2636  if (_v) {
2637  return _wrap_Attribute_AsDouble__SWIG_0(L);
2638  }
2639  }
2640  }
2641 
2642  lua_pushstring(L,"Wrong arguments for overloaded function 'Attribute_AsDouble'\n"
2643  " Possible C/C++ prototypes are:\n"
2644  " Mezzanine::XML::Attribute::AsDouble(double) const\n"
2645  " Mezzanine::XML::Attribute::AsDouble() const\n");
2646  lua_error(L);return 0;
2647 }
2648 
2649 
2650 static int _wrap_Attribute_AsFloat__SWIG_0(lua_State* L) {
2651  int SWIG_arg = 0;
2653  float arg2 ;
2654  float result;
2655 
2656  SWIG_check_num_args("Mezzanine::XML::Attribute::AsFloat",2,2)
2657  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Attribute::AsFloat",1,"Mezzanine::XML::Attribute const *");
2658  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::XML::Attribute::AsFloat",2,"float");
2659 
2660  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
2661  SWIG_fail_ptr("Attribute_AsFloat",1,SWIGTYPE_p_Mezzanine__XML__Attribute);
2662  }
2663 
2664  arg2 = (float)lua_tonumber(L, 2);
2665  result = (float)((Mezzanine::XML::Attribute const *)arg1)->AsFloat(arg2);
2666  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
2667  return SWIG_arg;
2668 
2669  if(0) SWIG_fail;
2670 
2671 fail:
2672  lua_error(L);
2673  return SWIG_arg;
2674 }
2675 
2676 
2677 static int _wrap_Attribute_AsFloat__SWIG_1(lua_State* L) {
2678  int SWIG_arg = 0;
2680  float result;
2681 
2682  SWIG_check_num_args("Mezzanine::XML::Attribute::AsFloat",1,1)
2683  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Attribute::AsFloat",1,"Mezzanine::XML::Attribute const *");
2684 
2685  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
2686  SWIG_fail_ptr("Attribute_AsFloat",1,SWIGTYPE_p_Mezzanine__XML__Attribute);
2687  }
2688 
2689  result = (float)((Mezzanine::XML::Attribute const *)arg1)->AsFloat();
2690  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
2691  return SWIG_arg;
2692 
2693  if(0) SWIG_fail;
2694 
2695 fail:
2696  lua_error(L);
2697  return SWIG_arg;
2698 }
2699 
2700 
2701 static int _wrap_Attribute_AsFloat(lua_State* L) {
2702  int argc;
2703  int argv[3]={
2704  1,2,3
2705  };
2706 
2707  argc = lua_gettop(L);
2708  if (argc == 1) {
2709  int _v;
2710  {
2711  void *ptr;
2712  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Attribute, 0)) {
2713  _v = 0;
2714  } else {
2715  _v = 1;
2716  }
2717  }
2718  if (_v) {
2719  return _wrap_Attribute_AsFloat__SWIG_1(L);
2720  }
2721  }
2722  if (argc == 2) {
2723  int _v;
2724  {
2725  void *ptr;
2726  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Attribute, 0)) {
2727  _v = 0;
2728  } else {
2729  _v = 1;
2730  }
2731  }
2732  if (_v) {
2733  {
2734  _v = lua_isnumber(L,argv[1]);
2735  }
2736  if (_v) {
2737  return _wrap_Attribute_AsFloat__SWIG_0(L);
2738  }
2739  }
2740  }
2741 
2742  lua_pushstring(L,"Wrong arguments for overloaded function 'Attribute_AsFloat'\n"
2743  " Possible C/C++ prototypes are:\n"
2744  " Mezzanine::XML::Attribute::AsFloat(float) const\n"
2745  " Mezzanine::XML::Attribute::AsFloat() const\n");
2746  lua_error(L);return 0;
2747 }
2748 
2749 
2750 static int _wrap_Attribute_AsReal__SWIG_0(lua_State* L) {
2751  int SWIG_arg = 0;
2753  Mezzanine::Real arg2 ;
2754  Mezzanine::Real result;
2755 
2756  SWIG_check_num_args("Mezzanine::XML::Attribute::AsReal",2,2)
2757  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Attribute::AsReal",1,"Mezzanine::XML::Attribute const *");
2758  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::XML::Attribute::AsReal",2,"Mezzanine::Real");
2759 
2760  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
2761  SWIG_fail_ptr("Attribute_AsReal",1,SWIGTYPE_p_Mezzanine__XML__Attribute);
2762  }
2763 
2764  arg2 = (Mezzanine::Real)lua_tonumber(L, 2);
2765  result = (Mezzanine::Real)((Mezzanine::XML::Attribute const *)arg1)->AsReal(arg2);
2766  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
2767  return SWIG_arg;
2768 
2769  if(0) SWIG_fail;
2770 
2771 fail:
2772  lua_error(L);
2773  return SWIG_arg;
2774 }
2775 
2776 
2777 static int _wrap_Attribute_AsReal__SWIG_1(lua_State* L) {
2778  int SWIG_arg = 0;
2780  Mezzanine::Real result;
2781 
2782  SWIG_check_num_args("Mezzanine::XML::Attribute::AsReal",1,1)
2783  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Attribute::AsReal",1,"Mezzanine::XML::Attribute const *");
2784 
2785  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
2786  SWIG_fail_ptr("Attribute_AsReal",1,SWIGTYPE_p_Mezzanine__XML__Attribute);
2787  }
2788 
2789  result = (Mezzanine::Real)((Mezzanine::XML::Attribute const *)arg1)->AsReal();
2790  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
2791  return SWIG_arg;
2792 
2793  if(0) SWIG_fail;
2794 
2795 fail:
2796  lua_error(L);
2797  return SWIG_arg;
2798 }
2799 
2800 
2801 static int _wrap_Attribute_AsReal(lua_State* L) {
2802  int argc;
2803  int argv[3]={
2804  1,2,3
2805  };
2806 
2807  argc = lua_gettop(L);
2808  if (argc == 1) {
2809  int _v;
2810  {
2811  void *ptr;
2812  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Attribute, 0)) {
2813  _v = 0;
2814  } else {
2815  _v = 1;
2816  }
2817  }
2818  if (_v) {
2819  return _wrap_Attribute_AsReal__SWIG_1(L);
2820  }
2821  }
2822  if (argc == 2) {
2823  int _v;
2824  {
2825  void *ptr;
2826  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Attribute, 0)) {
2827  _v = 0;
2828  } else {
2829  _v = 1;
2830  }
2831  }
2832  if (_v) {
2833  {
2834  _v = lua_isnumber(L,argv[1]);
2835  }
2836  if (_v) {
2837  return _wrap_Attribute_AsReal__SWIG_0(L);
2838  }
2839  }
2840  }
2841 
2842  lua_pushstring(L,"Wrong arguments for overloaded function 'Attribute_AsReal'\n"
2843  " Possible C/C++ prototypes are:\n"
2844  " Mezzanine::XML::Attribute::AsReal(Mezzanine::Real) const\n"
2845  " Mezzanine::XML::Attribute::AsReal() const\n");
2846  lua_error(L);return 0;
2847 }
2848 
2849 
2850 static int _wrap_Attribute_AsWhole__SWIG_0(lua_State* L) {
2851  int SWIG_arg = 0;
2853  Mezzanine::Whole arg2 ;
2854  Mezzanine::Whole result;
2855 
2856  SWIG_check_num_args("Mezzanine::XML::Attribute::AsWhole",2,2)
2857  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Attribute::AsWhole",1,"Mezzanine::XML::Attribute const *");
2858  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::XML::Attribute::AsWhole",2,"Mezzanine::Whole");
2859 
2860  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
2861  SWIG_fail_ptr("Attribute_AsWhole",1,SWIGTYPE_p_Mezzanine__XML__Attribute);
2862  }
2863 
2864  SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative")
2865  arg2 = (Mezzanine::Whole)lua_tonumber(L, 2);
2866  result = (Mezzanine::Whole)((Mezzanine::XML::Attribute const *)arg1)->AsWhole(arg2);
2867  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
2868  return SWIG_arg;
2869 
2870  if(0) SWIG_fail;
2871 
2872 fail:
2873  lua_error(L);
2874  return SWIG_arg;
2875 }
2876 
2877 
2878 static int _wrap_Attribute_AsWhole__SWIG_1(lua_State* L) {
2879  int SWIG_arg = 0;
2881  Mezzanine::Whole result;
2882 
2883  SWIG_check_num_args("Mezzanine::XML::Attribute::AsWhole",1,1)
2884  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Attribute::AsWhole",1,"Mezzanine::XML::Attribute const *");
2885 
2886  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
2887  SWIG_fail_ptr("Attribute_AsWhole",1,SWIGTYPE_p_Mezzanine__XML__Attribute);
2888  }
2889 
2890  result = (Mezzanine::Whole)((Mezzanine::XML::Attribute const *)arg1)->AsWhole();
2891  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
2892  return SWIG_arg;
2893 
2894  if(0) SWIG_fail;
2895 
2896 fail:
2897  lua_error(L);
2898  return SWIG_arg;
2899 }
2900 
2901 
2902 static int _wrap_Attribute_AsWhole(lua_State* L) {
2903  int argc;
2904  int argv[3]={
2905  1,2,3
2906  };
2907 
2908  argc = lua_gettop(L);
2909  if (argc == 1) {
2910  int _v;
2911  {
2912  void *ptr;
2913  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Attribute, 0)) {
2914  _v = 0;
2915  } else {
2916  _v = 1;
2917  }
2918  }
2919  if (_v) {
2920  return _wrap_Attribute_AsWhole__SWIG_1(L);
2921  }
2922  }
2923  if (argc == 2) {
2924  int _v;
2925  {
2926  void *ptr;
2927  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Attribute, 0)) {
2928  _v = 0;
2929  } else {
2930  _v = 1;
2931  }
2932  }
2933  if (_v) {
2934  {
2935  _v = lua_isnumber(L,argv[1]);
2936  }
2937  if (_v) {
2938  return _wrap_Attribute_AsWhole__SWIG_0(L);
2939  }
2940  }
2941  }
2942 
2943  lua_pushstring(L,"Wrong arguments for overloaded function 'Attribute_AsWhole'\n"
2944  " Possible C/C++ prototypes are:\n"
2945  " Mezzanine::XML::Attribute::AsWhole(Mezzanine::Whole) const\n"
2946  " Mezzanine::XML::Attribute::AsWhole() const\n");
2947  lua_error(L);return 0;
2948 }
2949 
2950 
2951 static int _wrap_Attribute_AsInteger__SWIG_0(lua_State* L) {
2952  int SWIG_arg = 0;
2954  Mezzanine::Integer arg2 ;
2955  Mezzanine::Integer result;
2956 
2957  SWIG_check_num_args("Mezzanine::XML::Attribute::AsInteger",2,2)
2958  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Attribute::AsInteger",1,"Mezzanine::XML::Attribute const *");
2959  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::XML::Attribute::AsInteger",2,"Mezzanine::Integer");
2960 
2961  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
2962  SWIG_fail_ptr("Attribute_AsInteger",1,SWIGTYPE_p_Mezzanine__XML__Attribute);
2963  }
2964 
2965  arg2 = (Mezzanine::Integer)lua_tonumber(L, 2);
2966  result = (Mezzanine::Integer)((Mezzanine::XML::Attribute const *)arg1)->AsInteger(arg2);
2967  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
2968  return SWIG_arg;
2969 
2970  if(0) SWIG_fail;
2971 
2972 fail:
2973  lua_error(L);
2974  return SWIG_arg;
2975 }
2976 
2977 
2978 static int _wrap_Attribute_AsInteger__SWIG_1(lua_State* L) {
2979  int SWIG_arg = 0;
2981  Mezzanine::Integer result;
2982 
2983  SWIG_check_num_args("Mezzanine::XML::Attribute::AsInteger",1,1)
2984  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Attribute::AsInteger",1,"Mezzanine::XML::Attribute const *");
2985 
2986  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
2987  SWIG_fail_ptr("Attribute_AsInteger",1,SWIGTYPE_p_Mezzanine__XML__Attribute);
2988  }
2989 
2990  result = (Mezzanine::Integer)((Mezzanine::XML::Attribute const *)arg1)->AsInteger();
2991  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
2992  return SWIG_arg;
2993 
2994  if(0) SWIG_fail;
2995 
2996 fail:
2997  lua_error(L);
2998  return SWIG_arg;
2999 }
3000 
3001 
3002 static int _wrap_Attribute_AsInteger(lua_State* L) {
3003  int argc;
3004  int argv[3]={
3005  1,2,3
3006  };
3007 
3008  argc = lua_gettop(L);
3009  if (argc == 1) {
3010  int _v;
3011  {
3012  void *ptr;
3013  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Attribute, 0)) {
3014  _v = 0;
3015  } else {
3016  _v = 1;
3017  }
3018  }
3019  if (_v) {
3020  return _wrap_Attribute_AsInteger__SWIG_1(L);
3021  }
3022  }
3023  if (argc == 2) {
3024  int _v;
3025  {
3026  void *ptr;
3027  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Attribute, 0)) {
3028  _v = 0;
3029  } else {
3030  _v = 1;
3031  }
3032  }
3033  if (_v) {
3034  {
3035  _v = lua_isnumber(L,argv[1]);
3036  }
3037  if (_v) {
3038  return _wrap_Attribute_AsInteger__SWIG_0(L);
3039  }
3040  }
3041  }
3042 
3043  lua_pushstring(L,"Wrong arguments for overloaded function 'Attribute_AsInteger'\n"
3044  " Possible C/C++ prototypes are:\n"
3045  " Mezzanine::XML::Attribute::AsInteger(Mezzanine::Integer) const\n"
3046  " Mezzanine::XML::Attribute::AsInteger() const\n");
3047  lua_error(L);return 0;
3048 }
3049 
3050 
3051 static int _wrap_Attribute_AsBool__SWIG_0(lua_State* L) {
3052  int SWIG_arg = 0;
3054  bool arg2 ;
3055  bool result;
3056 
3057  SWIG_check_num_args("Mezzanine::XML::Attribute::AsBool",2,2)
3058  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Attribute::AsBool",1,"Mezzanine::XML::Attribute const *");
3059  if(!lua_isboolean(L,2)) SWIG_fail_arg("Mezzanine::XML::Attribute::AsBool",2,"bool");
3060 
3061  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
3062  SWIG_fail_ptr("Attribute_AsBool",1,SWIGTYPE_p_Mezzanine__XML__Attribute);
3063  }
3064 
3065  arg2 = (lua_toboolean(L, 2)!=0);
3066  result = (bool)((Mezzanine::XML::Attribute const *)arg1)->AsBool(arg2);
3067  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
3068  return SWIG_arg;
3069 
3070  if(0) SWIG_fail;
3071 
3072 fail:
3073  lua_error(L);
3074  return SWIG_arg;
3075 }
3076 
3077 
3078 static int _wrap_Attribute_AsBool__SWIG_1(lua_State* L) {
3079  int SWIG_arg = 0;
3081  bool result;
3082 
3083  SWIG_check_num_args("Mezzanine::XML::Attribute::AsBool",1,1)
3084  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Attribute::AsBool",1,"Mezzanine::XML::Attribute const *");
3085 
3086  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
3087  SWIG_fail_ptr("Attribute_AsBool",1,SWIGTYPE_p_Mezzanine__XML__Attribute);
3088  }
3089 
3090  result = (bool)((Mezzanine::XML::Attribute const *)arg1)->AsBool();
3091  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
3092  return SWIG_arg;
3093 
3094  if(0) SWIG_fail;
3095 
3096 fail:
3097  lua_error(L);
3098  return SWIG_arg;
3099 }
3100 
3101 
3102 static int _wrap_Attribute_AsBool(lua_State* L) {
3103  int argc;
3104  int argv[3]={
3105  1,2,3
3106  };
3107 
3108  argc = lua_gettop(L);
3109  if (argc == 1) {
3110  int _v;
3111  {
3112  void *ptr;
3113  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Attribute, 0)) {
3114  _v = 0;
3115  } else {
3116  _v = 1;
3117  }
3118  }
3119  if (_v) {
3120  return _wrap_Attribute_AsBool__SWIG_1(L);
3121  }
3122  }
3123  if (argc == 2) {
3124  int _v;
3125  {
3126  void *ptr;
3127  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Attribute, 0)) {
3128  _v = 0;
3129  } else {
3130  _v = 1;
3131  }
3132  }
3133  if (_v) {
3134  {
3135  _v = lua_isboolean(L,argv[1]);
3136  }
3137  if (_v) {
3138  return _wrap_Attribute_AsBool__SWIG_0(L);
3139  }
3140  }
3141  }
3142 
3143  lua_pushstring(L,"Wrong arguments for overloaded function 'Attribute_AsBool'\n"
3144  " Possible C/C++ prototypes are:\n"
3145  " Mezzanine::XML::Attribute::AsBool(bool) const\n"
3146  " Mezzanine::XML::Attribute::AsBool() const\n");
3147  lua_error(L);return 0;
3148 }
3149 
3150 
3151 static int _wrap_Attribute_SetName(lua_State* L) {
3152  int SWIG_arg = 0;
3154  Mezzanine::String *arg2 = 0 ;
3155  Mezzanine::String temp2 ;
3156  bool result;
3157 
3158  SWIG_check_num_args("Mezzanine::XML::Attribute::SetName",2,2)
3159  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Attribute::SetName",1,"Mezzanine::XML::Attribute *");
3160  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Attribute::SetName",2,"Mezzanine::String const &");
3161 
3162  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
3163  SWIG_fail_ptr("Attribute_SetName",1,SWIGTYPE_p_Mezzanine__XML__Attribute);
3164  }
3165 
3166  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
3167  result = (bool)(arg1)->SetName((Mezzanine::String const &)*arg2);
3168  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
3169  return SWIG_arg;
3170 
3171  if(0) SWIG_fail;
3172 
3173 fail:
3174  lua_error(L);
3175  return SWIG_arg;
3176 }
3177 
3178 
3179 static int _wrap_Attribute_SetValue(lua_State* L) {
3180  int SWIG_arg = 0;
3182  Mezzanine::String *arg2 = 0 ;
3183  Mezzanine::String temp2 ;
3184  bool result;
3185 
3186  SWIG_check_num_args("Mezzanine::XML::Attribute::SetValue",2,2)
3187  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Attribute::SetValue",1,"Mezzanine::XML::Attribute *");
3188  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Attribute::SetValue",2,"Mezzanine::String const &");
3189 
3190  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
3191  SWIG_fail_ptr("Attribute_SetValue",1,SWIGTYPE_p_Mezzanine__XML__Attribute);
3192  }
3193 
3194  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
3195  result = (bool)(arg1)->SetValue((Mezzanine::String const &)*arg2);
3196  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
3197  return SWIG_arg;
3198 
3199  if(0) SWIG_fail;
3200 
3201 fail:
3202  lua_error(L);
3203  return SWIG_arg;
3204 }
3205 
3206 
3207 static int _wrap_Attribute_GetNextAttribute(lua_State* L) {
3208  int SWIG_arg = 0;
3211 
3212  SWIG_check_num_args("Mezzanine::XML::Attribute::GetNextAttribute",1,1)
3213  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Attribute::GetNextAttribute",1,"Mezzanine::XML::Attribute const *");
3214 
3215  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
3216  SWIG_fail_ptr("Attribute_GetNextAttribute",1,SWIGTYPE_p_Mezzanine__XML__Attribute);
3217  }
3218 
3219  result = ((Mezzanine::XML::Attribute const *)arg1)->GetNextAttribute();
3220  {
3222  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Attribute,1); SWIG_arg++;
3223  }
3224  return SWIG_arg;
3225 
3226  if(0) SWIG_fail;
3227 
3228 fail:
3229  lua_error(L);
3230  return SWIG_arg;
3231 }
3232 
3233 
3234 static int _wrap_Attribute_GetPreviousAttribute(lua_State* L) {
3235  int SWIG_arg = 0;
3238 
3239  SWIG_check_num_args("Mezzanine::XML::Attribute::GetPreviousAttribute",1,1)
3240  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Attribute::GetPreviousAttribute",1,"Mezzanine::XML::Attribute const *");
3241 
3242  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
3243  SWIG_fail_ptr("Attribute_GetPreviousAttribute",1,SWIGTYPE_p_Mezzanine__XML__Attribute);
3244  }
3245 
3246  result = ((Mezzanine::XML::Attribute const *)arg1)->GetPreviousAttribute();
3247  {
3249  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Attribute,1); SWIG_arg++;
3250  }
3251  return SWIG_arg;
3252 
3253  if(0) SWIG_fail;
3254 
3255 fail:
3256  lua_error(L);
3257  return SWIG_arg;
3258 }
3259 
3260 
3261 static int _wrap_Attribute_HashValue(lua_State* L) {
3262  int SWIG_arg = 0;
3264  size_t result;
3265 
3266  SWIG_check_num_args("Mezzanine::XML::Attribute::HashValue",1,1)
3267  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Attribute::HashValue",1,"Mezzanine::XML::Attribute const *");
3268 
3269  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
3270  SWIG_fail_ptr("Attribute_HashValue",1,SWIGTYPE_p_Mezzanine__XML__Attribute);
3271  }
3272 
3273  result = ((Mezzanine::XML::Attribute const *)arg1)->HashValue();
3274  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
3275  return SWIG_arg;
3276 
3277  if(0) SWIG_fail;
3278 
3279 fail:
3280  lua_error(L);
3281  return SWIG_arg;
3282 }
3283 
3284 
3285 static int _wrap_Attribute_InternalObject(lua_State* L) {
3286  int SWIG_arg = 0;
3288  Mezzanine::XML::AttributeStruct *result = 0 ;
3289 
3290  SWIG_check_num_args("Mezzanine::XML::Attribute::InternalObject",1,1)
3291  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Attribute::InternalObject",1,"Mezzanine::XML::Attribute const *");
3292 
3293  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
3294  SWIG_fail_ptr("Attribute_InternalObject",1,SWIGTYPE_p_Mezzanine__XML__Attribute);
3295  }
3296 
3297  result = (Mezzanine::XML::AttributeStruct *)((Mezzanine::XML::Attribute const *)arg1)->InternalObject();
3298  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__XML__AttributeStruct,0); SWIG_arg++;
3299  return SWIG_arg;
3300 
3301  if(0) SWIG_fail;
3302 
3303 fail:
3304  lua_error(L);
3305  return SWIG_arg;
3306 }
3307 
3308 
3309 static void swig_delete_Attribute(void *obj) {
3311 delete arg1;
3312 }
3313 static swig_lua_method swig_Mezzanine_XML_Attribute_methods[] = {
3314  {"__lt", _wrap_Attribute___lt},
3315  {"__le", _wrap_Attribute___le},
3316  {"Empty", _wrap_Attribute_Empty},
3317  {"Name", _wrap_Attribute_Name},
3318  {"Value", _wrap_Attribute_Value},
3319  {"AsString", _wrap_Attribute_AsString},
3320  {"AsInt", _wrap_Attribute_AsInt},
3321  {"AsUint", _wrap_Attribute_AsUint},
3322  {"AsDouble", _wrap_Attribute_AsDouble},
3323  {"AsFloat", _wrap_Attribute_AsFloat},
3324  {"AsReal", _wrap_Attribute_AsReal},
3325  {"AsWhole", _wrap_Attribute_AsWhole},
3326  {"AsInteger", _wrap_Attribute_AsInteger},
3327  {"AsBool", _wrap_Attribute_AsBool},
3328  {"SetName", _wrap_Attribute_SetName},
3329  {"SetValue", _wrap_Attribute_SetValue},
3330  {"GetNextAttribute", _wrap_Attribute_GetNextAttribute},
3331  {"GetPreviousAttribute", _wrap_Attribute_GetPreviousAttribute},
3332  {"HashValue", _wrap_Attribute_HashValue},
3333  {"InternalObject", _wrap_Attribute_InternalObject},
3334  {0,0}
3335 };
3336 static swig_lua_attribute swig_Mezzanine_XML_Attribute_attributes[] = {
3337  {0,0,0}
3338 };
3339 static swig_lua_class *swig_Mezzanine_XML_Attribute_bases[] = {0};
3340 static const char *swig_Mezzanine_XML_Attribute_base_names[] = {0};
3341 static swig_lua_class _wrap_class_Mezzanine_XML_Attribute = { "Attribute", &SWIGTYPE_p_Mezzanine__XML__Attribute,_wrap_new_Attribute, swig_delete_Attribute, swig_Mezzanine_XML_Attribute_methods, swig_Mezzanine_XML_Attribute_attributes, swig_Mezzanine_XML_Attribute_bases, swig_Mezzanine_XML_Attribute_base_names };
3342 
3343 static int _wrap_ParseMinimal_get(lua_State* L) {
3344  int SWIG_arg = 0;
3345  unsigned int result;
3346 
3347  SWIG_check_num_args("Mezzanine::XML::ParseMinimal",0,0)
3348  result = (unsigned int)(unsigned int)Mezzanine::XML::ParseMinimal;
3349  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
3350  return SWIG_arg;
3351 
3352  if(0) SWIG_fail;
3353 
3354 fail:
3355  lua_error(L);
3356  return SWIG_arg;
3357 }
3358 
3359 
3360 static int _wrap_ParsePi_get(lua_State* L) {
3361  int SWIG_arg = 0;
3362  unsigned int result;
3363 
3364  SWIG_check_num_args("Mezzanine::XML::ParsePi",0,0)
3365  result = (unsigned int)(unsigned int)Mezzanine::XML::ParsePi;
3366  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
3367  return SWIG_arg;
3368 
3369  if(0) SWIG_fail;
3370 
3371 fail:
3372  lua_error(L);
3373  return SWIG_arg;
3374 }
3375 
3376 
3377 static int _wrap_ParseComments_get(lua_State* L) {
3378  int SWIG_arg = 0;
3379  unsigned int result;
3380 
3381  SWIG_check_num_args("Mezzanine::XML::ParseComments",0,0)
3382  result = (unsigned int)(unsigned int)Mezzanine::XML::ParseComments;
3383  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
3384  return SWIG_arg;
3385 
3386  if(0) SWIG_fail;
3387 
3388 fail:
3389  lua_error(L);
3390  return SWIG_arg;
3391 }
3392 
3393 
3394 static int _wrap_ParseCdata_get(lua_State* L) {
3395  int SWIG_arg = 0;
3396  unsigned int result;
3397 
3398  SWIG_check_num_args("Mezzanine::XML::ParseCdata",0,0)
3399  result = (unsigned int)(unsigned int)Mezzanine::XML::ParseCdata;
3400  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
3401  return SWIG_arg;
3402 
3403  if(0) SWIG_fail;
3404 
3405 fail:
3406  lua_error(L);
3407  return SWIG_arg;
3408 }
3409 
3410 
3411 static int _wrap_ParseWsPcdata_get(lua_State* L) {
3412  int SWIG_arg = 0;
3413  unsigned int result;
3414 
3415  SWIG_check_num_args("Mezzanine::XML::ParseWsPcdata",0,0)
3416  result = (unsigned int)(unsigned int)Mezzanine::XML::ParseWsPcdata;
3417  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
3418  return SWIG_arg;
3419 
3420  if(0) SWIG_fail;
3421 
3422 fail:
3423  lua_error(L);
3424  return SWIG_arg;
3425 }
3426 
3427 
3428 static int _wrap_ParseEscapes_get(lua_State* L) {
3429  int SWIG_arg = 0;
3430  unsigned int result;
3431 
3432  SWIG_check_num_args("Mezzanine::XML::ParseEscapes",0,0)
3433  result = (unsigned int)(unsigned int)Mezzanine::XML::ParseEscapes;
3434  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
3435  return SWIG_arg;
3436 
3437  if(0) SWIG_fail;
3438 
3439 fail:
3440  lua_error(L);
3441  return SWIG_arg;
3442 }
3443 
3444 
3445 static int _wrap_ParseEol_get(lua_State* L) {
3446  int SWIG_arg = 0;
3447  unsigned int result;
3448 
3449  SWIG_check_num_args("Mezzanine::XML::ParseEol",0,0)
3450  result = (unsigned int)(unsigned int)Mezzanine::XML::ParseEol;
3451  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
3452  return SWIG_arg;
3453 
3454  if(0) SWIG_fail;
3455 
3456 fail:
3457  lua_error(L);
3458  return SWIG_arg;
3459 }
3460 
3461 
3462 static int _wrap_ParseWconvAttribute_get(lua_State* L) {
3463  int SWIG_arg = 0;
3464  unsigned int result;
3465 
3466  SWIG_check_num_args("Mezzanine::XML::ParseWconvAttribute",0,0)
3467  result = (unsigned int)(unsigned int)Mezzanine::XML::ParseWconvAttribute;
3468  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
3469  return SWIG_arg;
3470 
3471  if(0) SWIG_fail;
3472 
3473 fail:
3474  lua_error(L);
3475  return SWIG_arg;
3476 }
3477 
3478 
3479 static int _wrap_ParseWnormAttribute_get(lua_State* L) {
3480  int SWIG_arg = 0;
3481  unsigned int result;
3482 
3483  SWIG_check_num_args("Mezzanine::XML::ParseWnormAttribute",0,0)
3484  result = (unsigned int)(unsigned int)Mezzanine::XML::ParseWnormAttribute;
3485  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
3486  return SWIG_arg;
3487 
3488  if(0) SWIG_fail;
3489 
3490 fail:
3491  lua_error(L);
3492  return SWIG_arg;
3493 }
3494 
3495 
3496 static int _wrap_ParseDeclaration_get(lua_State* L) {
3497  int SWIG_arg = 0;
3498  unsigned int result;
3499 
3500  SWIG_check_num_args("Mezzanine::XML::ParseDeclaration",0,0)
3501  result = (unsigned int)(unsigned int)Mezzanine::XML::ParseDeclaration;
3502  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
3503  return SWIG_arg;
3504 
3505  if(0) SWIG_fail;
3506 
3507 fail:
3508  lua_error(L);
3509  return SWIG_arg;
3510 }
3511 
3512 
3513 static int _wrap_ParseDocType_get(lua_State* L) {
3514  int SWIG_arg = 0;
3515  unsigned int result;
3516 
3517  SWIG_check_num_args("Mezzanine::XML::ParseDocType",0,0)
3518  result = (unsigned int)(unsigned int)Mezzanine::XML::ParseDocType;
3519  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
3520  return SWIG_arg;
3521 
3522  if(0) SWIG_fail;
3523 
3524 fail:
3525  lua_error(L);
3526  return SWIG_arg;
3527 }
3528 
3529 
3530 static int _wrap_ParseWsPcdata_single_get(lua_State* L) {
3531  int SWIG_arg = 0;
3532  unsigned int result;
3533 
3534  SWIG_check_num_args("Mezzanine::XML::ParseWsPcdata_single",0,0)
3535  result = (unsigned int)(unsigned int)Mezzanine::XML::ParseWsPcdata_single;
3536  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
3537  return SWIG_arg;
3538 
3539  if(0) SWIG_fail;
3540 
3541 fail:
3542  lua_error(L);
3543  return SWIG_arg;
3544 }
3545 
3546 
3547 static int _wrap_ParseDefault_get(lua_State* L) {
3548  int SWIG_arg = 0;
3549  unsigned int result;
3550 
3551  SWIG_check_num_args("Mezzanine::XML::ParseDefault",0,0)
3552  result = (unsigned int)(unsigned int)Mezzanine::XML::ParseDefault;
3553  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
3554  return SWIG_arg;
3555 
3556  if(0) SWIG_fail;
3557 
3558 fail:
3559  lua_error(L);
3560  return SWIG_arg;
3561 }
3562 
3563 
3564 static int _wrap_ParseFull_get(lua_State* L) {
3565  int SWIG_arg = 0;
3566  unsigned int result;
3567 
3568  SWIG_check_num_args("Mezzanine::XML::ParseFull",0,0)
3569  result = (unsigned int)(unsigned int)Mezzanine::XML::ParseFull;
3570  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
3571  return SWIG_arg;
3572 
3573  if(0) SWIG_fail;
3574 
3575 fail:
3576  lua_error(L);
3577  return SWIG_arg;
3578 }
3579 
3580 
3581 static int _wrap_FormatIndent_get(lua_State* L) {
3582  int SWIG_arg = 0;
3583  unsigned int result;
3584 
3585  SWIG_check_num_args("Mezzanine::XML::FormatIndent",0,0)
3586  result = (unsigned int)(unsigned int)Mezzanine::XML::FormatIndent;
3587  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
3588  return SWIG_arg;
3589 
3590  if(0) SWIG_fail;
3591 
3592 fail:
3593  lua_error(L);
3594  return SWIG_arg;
3595 }
3596 
3597 
3598 static int _wrap_FormatWriteBom_get(lua_State* L) {
3599  int SWIG_arg = 0;
3600  unsigned int result;
3601 
3602  SWIG_check_num_args("Mezzanine::XML::FormatWriteBom",0,0)
3603  result = (unsigned int)(unsigned int)Mezzanine::XML::FormatWriteBom;
3604  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
3605  return SWIG_arg;
3606 
3607  if(0) SWIG_fail;
3608 
3609 fail:
3610  lua_error(L);
3611  return SWIG_arg;
3612 }
3613 
3614 
3615 static int _wrap_FormatRaw_get(lua_State* L) {
3616  int SWIG_arg = 0;
3617  unsigned int result;
3618 
3619  SWIG_check_num_args("Mezzanine::XML::FormatRaw",0,0)
3620  result = (unsigned int)(unsigned int)Mezzanine::XML::FormatRaw;
3621  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
3622  return SWIG_arg;
3623 
3624  if(0) SWIG_fail;
3625 
3626 fail:
3627  lua_error(L);
3628  return SWIG_arg;
3629 }
3630 
3631 
3632 static int _wrap_FormatNoDeclaration_get(lua_State* L) {
3633  int SWIG_arg = 0;
3634  unsigned int result;
3635 
3636  SWIG_check_num_args("Mezzanine::XML::FormatNoDeclaration",0,0)
3637  result = (unsigned int)(unsigned int)Mezzanine::XML::FormatNoDeclaration;
3638  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
3639  return SWIG_arg;
3640 
3641  if(0) SWIG_fail;
3642 
3643 fail:
3644  lua_error(L);
3645  return SWIG_arg;
3646 }
3647 
3648 
3649 static int _wrap_FormatNoEscapes_get(lua_State* L) {
3650  int SWIG_arg = 0;
3651  unsigned int result;
3652 
3653  SWIG_check_num_args("Mezzanine::XML::FormatNoEscapes",0,0)
3654  result = (unsigned int)(unsigned int)Mezzanine::XML::FormatNoEscapes;
3655  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
3656  return SWIG_arg;
3657 
3658  if(0) SWIG_fail;
3659 
3660 fail:
3661  lua_error(L);
3662  return SWIG_arg;
3663 }
3664 
3665 
3666 static int _wrap_FormatSaveFileText_get(lua_State* L) {
3667  int SWIG_arg = 0;
3668  unsigned int result;
3669 
3670  SWIG_check_num_args("Mezzanine::XML::FormatSaveFileText",0,0)
3671  result = (unsigned int)(unsigned int)Mezzanine::XML::FormatSaveFileText;
3672  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
3673  return SWIG_arg;
3674 
3675  if(0) SWIG_fail;
3676 
3677 fail:
3678  lua_error(L);
3679  return SWIG_arg;
3680 }
3681 
3682 
3683 static int _wrap_FormatDefault_get(lua_State* L) {
3684  int SWIG_arg = 0;
3685  unsigned int result;
3686 
3687  SWIG_check_num_args("Mezzanine::XML::FormatDefault",0,0)
3688  result = (unsigned int)(unsigned int)Mezzanine::XML::FormatDefault;
3689  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
3690  return SWIG_arg;
3691 
3692  if(0) SWIG_fail;
3693 
3694 fail:
3695  lua_error(L);
3696  return SWIG_arg;
3697 }
3698 
3699 
3700 static int _wrap_new_Node__SWIG_0(lua_State* L) {
3701  int SWIG_arg = 0;
3702  Mezzanine::XML::Node *result = 0 ;
3703 
3704  SWIG_check_num_args("Mezzanine::XML::Node::Node",0,0)
3705  result = (Mezzanine::XML::Node *)new Mezzanine::XML::Node();
3706  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
3707  return SWIG_arg;
3708 
3709  if(0) SWIG_fail;
3710 
3711 fail:
3712  lua_error(L);
3713  return SWIG_arg;
3714 }
3715 
3716 
3717 static int _wrap_new_Node__SWIG_1(lua_State* L) {
3718  int SWIG_arg = 0;
3719  Mezzanine::XML::NodeStruct *arg1 = (Mezzanine::XML::NodeStruct *) 0 ;
3720  Mezzanine::XML::Node *result = 0 ;
3721 
3722  SWIG_check_num_args("Mezzanine::XML::Node::Node",1,1)
3723  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Node",1,"Mezzanine::XML::NodeStruct *");
3724 
3725  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeStruct,0))){
3726  SWIG_fail_ptr("new_Node",1,SWIGTYPE_p_Mezzanine__XML__NodeStruct);
3727  }
3728 
3729  result = (Mezzanine::XML::Node *)new Mezzanine::XML::Node(arg1);
3730  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
3731  return SWIG_arg;
3732 
3733  if(0) SWIG_fail;
3734 
3735 fail:
3736  lua_error(L);
3737  return SWIG_arg;
3738 }
3739 
3740 
3741 static int _wrap_new_Node(lua_State* L) {
3742  int argc;
3743  int argv[2]={
3744  1,2
3745  };
3746 
3747  argc = lua_gettop(L);
3748  if (argc == 0) {
3749  return _wrap_new_Node__SWIG_0(L);
3750  }
3751  if (argc == 1) {
3752  int _v;
3753  {
3754  void *ptr;
3755  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeStruct, 0)) {
3756  _v = 0;
3757  } else {
3758  _v = 1;
3759  }
3760  }
3761  if (_v) {
3762  return _wrap_new_Node__SWIG_1(L);
3763  }
3764  }
3765 
3766  lua_pushstring(L,"Wrong arguments for overloaded function 'new_Node'\n"
3767  " Possible C/C++ prototypes are:\n"
3768  " Mezzanine::XML::Node::Node()\n"
3769  " Mezzanine::XML::Node::Node(Mezzanine::XML::NodeStruct *)\n");
3770  lua_error(L);return 0;
3771 }
3772 
3773 
3774 static int _wrap_Node___lt(lua_State* L) {
3775  int SWIG_arg = 0;
3777  Mezzanine::XML::Node *arg2 = 0 ;
3778  bool result;
3779 
3780  SWIG_check_num_args("Mezzanine::XML::Node::operator <",2,2)
3781  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::operator <",1,"Mezzanine::XML::Node const *");
3782  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::operator <",2,"Mezzanine::XML::Node const &");
3783 
3784  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
3785  SWIG_fail_ptr("Node___lt",1,SWIGTYPE_p_Mezzanine__XML__Node);
3786  }
3787 
3788 
3789  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Node,0))){
3790  SWIG_fail_ptr("Node___lt",2,SWIGTYPE_p_Mezzanine__XML__Node);
3791  }
3792 
3793  result = (bool)((Mezzanine::XML::Node const *)arg1)->operator <((Mezzanine::XML::Node const &)*arg2);
3794  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
3795  return SWIG_arg;
3796 
3797  if(0) SWIG_fail;
3798 
3799 fail:
3800  lua_error(L);
3801  return SWIG_arg;
3802 }
3803 
3804 
3805 static int _wrap_Node___le(lua_State* L) {
3806  int SWIG_arg = 0;
3808  Mezzanine::XML::Node *arg2 = 0 ;
3809  bool result;
3810 
3811  SWIG_check_num_args("Mezzanine::XML::Node::operator <=",2,2)
3812  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::operator <=",1,"Mezzanine::XML::Node const *");
3813  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::operator <=",2,"Mezzanine::XML::Node const &");
3814 
3815  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
3816  SWIG_fail_ptr("Node___le",1,SWIGTYPE_p_Mezzanine__XML__Node);
3817  }
3818 
3819 
3820  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Node,0))){
3821  SWIG_fail_ptr("Node___le",2,SWIGTYPE_p_Mezzanine__XML__Node);
3822  }
3823 
3824  result = (bool)((Mezzanine::XML::Node const *)arg1)->operator <=((Mezzanine::XML::Node const &)*arg2);
3825  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
3826  return SWIG_arg;
3827 
3828  if(0) SWIG_fail;
3829 
3830 fail:
3831  lua_error(L);
3832  return SWIG_arg;
3833 }
3834 
3835 
3836 static int _wrap_Node_Empty(lua_State* L) {
3837  int SWIG_arg = 0;
3839  bool result;
3840 
3841  SWIG_check_num_args("Mezzanine::XML::Node::Empty",1,1)
3842  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Empty",1,"Mezzanine::XML::Node const *");
3843 
3844  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
3845  SWIG_fail_ptr("Node_Empty",1,SWIGTYPE_p_Mezzanine__XML__Node);
3846  }
3847 
3848  result = (bool)((Mezzanine::XML::Node const *)arg1)->Empty();
3849  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
3850  return SWIG_arg;
3851 
3852  if(0) SWIG_fail;
3853 
3854 fail:
3855  lua_error(L);
3856  return SWIG_arg;
3857 }
3858 
3859 
3860 static int _wrap_Node_Type(lua_State* L) {
3861  int SWIG_arg = 0;
3863  Mezzanine::XML::NodeType result;
3864 
3865  SWIG_check_num_args("Mezzanine::XML::Node::Type",1,1)
3866  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Type",1,"Mezzanine::XML::Node const *");
3867 
3868  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
3869  SWIG_fail_ptr("Node_Type",1,SWIGTYPE_p_Mezzanine__XML__Node);
3870  }
3871 
3872  result = (Mezzanine::XML::NodeType)((Mezzanine::XML::Node const *)arg1)->Type();
3873  lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++;
3874  return SWIG_arg;
3875 
3876  if(0) SWIG_fail;
3877 
3878 fail:
3879  lua_error(L);
3880  return SWIG_arg;
3881 }
3882 
3883 
3884 static int _wrap_Node_Name(lua_State* L) {
3885  int SWIG_arg = 0;
3887  Mezzanine::Char8 *result = 0 ;
3888 
3889  SWIG_check_num_args("Mezzanine::XML::Node::Name",1,1)
3890  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Name",1,"Mezzanine::XML::Node const *");
3891 
3892  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
3893  SWIG_fail_ptr("Node_Name",1,SWIGTYPE_p_Mezzanine__XML__Node);
3894  }
3895 
3896  result = (Mezzanine::Char8 *)((Mezzanine::XML::Node const *)arg1)->Name();
3897  lua_pushstring(L,(const char *)result); SWIG_arg++;
3898  return SWIG_arg;
3899 
3900  if(0) SWIG_fail;
3901 
3902 fail:
3903  lua_error(L);
3904  return SWIG_arg;
3905 }
3906 
3907 
3908 static int _wrap_Node_Value(lua_State* L) {
3909  int SWIG_arg = 0;
3911  Mezzanine::Char8 *result = 0 ;
3912 
3913  SWIG_check_num_args("Mezzanine::XML::Node::Value",1,1)
3914  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Value",1,"Mezzanine::XML::Node const *");
3915 
3916  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
3917  SWIG_fail_ptr("Node_Value",1,SWIGTYPE_p_Mezzanine__XML__Node);
3918  }
3919 
3920  result = (Mezzanine::Char8 *)((Mezzanine::XML::Node const *)arg1)->Value();
3921  lua_pushstring(L,(const char *)result); SWIG_arg++;
3922  return SWIG_arg;
3923 
3924  if(0) SWIG_fail;
3925 
3926 fail:
3927  lua_error(L);
3928  return SWIG_arg;
3929 }
3930 
3931 
3932 static int _wrap_Node_GetFirstAttribute(lua_State* L) {
3933  int SWIG_arg = 0;
3936 
3937  SWIG_check_num_args("Mezzanine::XML::Node::GetFirstAttribute",1,1)
3938  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::GetFirstAttribute",1,"Mezzanine::XML::Node const *");
3939 
3940  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
3941  SWIG_fail_ptr("Node_GetFirstAttribute",1,SWIGTYPE_p_Mezzanine__XML__Node);
3942  }
3943 
3944  result = ((Mezzanine::XML::Node const *)arg1)->GetFirstAttribute();
3945  {
3947  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Attribute,1); SWIG_arg++;
3948  }
3949  return SWIG_arg;
3950 
3951  if(0) SWIG_fail;
3952 
3953 fail:
3954  lua_error(L);
3955  return SWIG_arg;
3956 }
3957 
3958 
3959 static int _wrap_Node_GetLastAttribute(lua_State* L) {
3960  int SWIG_arg = 0;
3963 
3964  SWIG_check_num_args("Mezzanine::XML::Node::GetLastAttribute",1,1)
3965  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::GetLastAttribute",1,"Mezzanine::XML::Node const *");
3966 
3967  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
3968  SWIG_fail_ptr("Node_GetLastAttribute",1,SWIGTYPE_p_Mezzanine__XML__Node);
3969  }
3970 
3971  result = ((Mezzanine::XML::Node const *)arg1)->GetLastAttribute();
3972  {
3974  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Attribute,1); SWIG_arg++;
3975  }
3976  return SWIG_arg;
3977 
3978  if(0) SWIG_fail;
3979 
3980 fail:
3981  lua_error(L);
3982  return SWIG_arg;
3983 }
3984 
3985 
3986 static int _wrap_Node_GetFirstChild(lua_State* L) {
3987  int SWIG_arg = 0;
3989  Mezzanine::XML::Node result;
3990 
3991  SWIG_check_num_args("Mezzanine::XML::Node::GetFirstChild",1,1)
3992  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::GetFirstChild",1,"Mezzanine::XML::Node const *");
3993 
3994  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
3995  SWIG_fail_ptr("Node_GetFirstChild",1,SWIGTYPE_p_Mezzanine__XML__Node);
3996  }
3997 
3998  result = ((Mezzanine::XML::Node const *)arg1)->GetFirstChild();
3999  {
4000  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
4001  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
4002  }
4003  return SWIG_arg;
4004 
4005  if(0) SWIG_fail;
4006 
4007 fail:
4008  lua_error(L);
4009  return SWIG_arg;
4010 }
4011 
4012 
4013 static int _wrap_Node_GetLastChild(lua_State* L) {
4014  int SWIG_arg = 0;
4016  Mezzanine::XML::Node result;
4017 
4018  SWIG_check_num_args("Mezzanine::XML::Node::GetLastChild",1,1)
4019  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::GetLastChild",1,"Mezzanine::XML::Node const *");
4020 
4021  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
4022  SWIG_fail_ptr("Node_GetLastChild",1,SWIGTYPE_p_Mezzanine__XML__Node);
4023  }
4024 
4025  result = ((Mezzanine::XML::Node const *)arg1)->GetLastChild();
4026  {
4027  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
4028  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
4029  }
4030  return SWIG_arg;
4031 
4032  if(0) SWIG_fail;
4033 
4034 fail:
4035  lua_error(L);
4036  return SWIG_arg;
4037 }
4038 
4039 
4040 static int _wrap_Node_GetNextSibling__SWIG_0(lua_State* L) {
4041  int SWIG_arg = 0;
4043  Mezzanine::XML::Node result;
4044 
4045  SWIG_check_num_args("Mezzanine::XML::Node::GetNextSibling",1,1)
4046  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::GetNextSibling",1,"Mezzanine::XML::Node const *");
4047 
4048  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
4049  SWIG_fail_ptr("Node_GetNextSibling",1,SWIGTYPE_p_Mezzanine__XML__Node);
4050  }
4051 
4052  result = ((Mezzanine::XML::Node const *)arg1)->GetNextSibling();
4053  {
4054  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
4055  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
4056  }
4057  return SWIG_arg;
4058 
4059  if(0) SWIG_fail;
4060 
4061 fail:
4062  lua_error(L);
4063  return SWIG_arg;
4064 }
4065 
4066 
4067 static int _wrap_Node_GetPreviousSibling__SWIG_0(lua_State* L) {
4068  int SWIG_arg = 0;
4070  Mezzanine::XML::Node result;
4071 
4072  SWIG_check_num_args("Mezzanine::XML::Node::GetPreviousSibling",1,1)
4073  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::GetPreviousSibling",1,"Mezzanine::XML::Node const *");
4074 
4075  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
4076  SWIG_fail_ptr("Node_GetPreviousSibling",1,SWIGTYPE_p_Mezzanine__XML__Node);
4077  }
4078 
4079  result = ((Mezzanine::XML::Node const *)arg1)->GetPreviousSibling();
4080  {
4081  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
4082  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
4083  }
4084  return SWIG_arg;
4085 
4086  if(0) SWIG_fail;
4087 
4088 fail:
4089  lua_error(L);
4090  return SWIG_arg;
4091 }
4092 
4093 
4094 static int _wrap_Node_GetParent(lua_State* L) {
4095  int SWIG_arg = 0;
4097  Mezzanine::XML::Node result;
4098 
4099  SWIG_check_num_args("Mezzanine::XML::Node::GetParent",1,1)
4100  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::GetParent",1,"Mezzanine::XML::Node const *");
4101 
4102  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
4103  SWIG_fail_ptr("Node_GetParent",1,SWIGTYPE_p_Mezzanine__XML__Node);
4104  }
4105 
4106  result = ((Mezzanine::XML::Node const *)arg1)->GetParent();
4107  {
4108  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
4109  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
4110  }
4111  return SWIG_arg;
4112 
4113  if(0) SWIG_fail;
4114 
4115 fail:
4116  lua_error(L);
4117  return SWIG_arg;
4118 }
4119 
4120 
4121 static int _wrap_Node_GetRoot(lua_State* L) {
4122  int SWIG_arg = 0;
4124  Mezzanine::XML::Node result;
4125 
4126  SWIG_check_num_args("Mezzanine::XML::Node::GetRoot",1,1)
4127  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::GetRoot",1,"Mezzanine::XML::Node const *");
4128 
4129  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
4130  SWIG_fail_ptr("Node_GetRoot",1,SWIGTYPE_p_Mezzanine__XML__Node);
4131  }
4132 
4133  result = ((Mezzanine::XML::Node const *)arg1)->GetRoot();
4134  {
4135  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
4136  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
4137  }
4138  return SWIG_arg;
4139 
4140  if(0) SWIG_fail;
4141 
4142 fail:
4143  lua_error(L);
4144  return SWIG_arg;
4145 }
4146 
4147 
4148 static int _wrap_Node_GetText(lua_State* L) {
4149  int SWIG_arg = 0;
4151  Mezzanine::XML::NodeText result;
4152 
4153  SWIG_check_num_args("Mezzanine::XML::Node::GetText",1,1)
4154  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::GetText",1,"Mezzanine::XML::Node const *");
4155 
4156  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
4157  SWIG_fail_ptr("Node_GetText",1,SWIGTYPE_p_Mezzanine__XML__Node);
4158  }
4159 
4160  result = ((Mezzanine::XML::Node const *)arg1)->GetText();
4161  {
4163  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__NodeText,1); SWIG_arg++;
4164  }
4165  return SWIG_arg;
4166 
4167  if(0) SWIG_fail;
4168 
4169 fail:
4170  lua_error(L);
4171  return SWIG_arg;
4172 }
4173 
4174 
4175 static int _wrap_Node_GetChild(lua_State* L) {
4176  int SWIG_arg = 0;
4178  Mezzanine::String *arg2 = 0 ;
4179  Mezzanine::String temp2 ;
4180  Mezzanine::XML::Node result;
4181 
4182  SWIG_check_num_args("Mezzanine::XML::Node::GetChild",2,2)
4183  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::GetChild",1,"Mezzanine::XML::Node const *");
4184  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::GetChild",2,"Mezzanine::String const &");
4185 
4186  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
4187  SWIG_fail_ptr("Node_GetChild",1,SWIGTYPE_p_Mezzanine__XML__Node);
4188  }
4189 
4190  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
4191  result = ((Mezzanine::XML::Node const *)arg1)->GetChild((Mezzanine::String const &)*arg2);
4192  {
4193  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
4194  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
4195  }
4196  return SWIG_arg;
4197 
4198  if(0) SWIG_fail;
4199 
4200 fail:
4201  lua_error(L);
4202  return SWIG_arg;
4203 }
4204 
4205 
4206 static int _wrap_Node_GetAttribute(lua_State* L) {
4207  int SWIG_arg = 0;
4209  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
4211 
4212  SWIG_check_num_args("Mezzanine::XML::Node::GetAttribute",2,2)
4213  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::GetAttribute",1,"Mezzanine::XML::Node const *");
4214  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::GetAttribute",2,"Mezzanine::Char8 const *");
4215 
4216  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
4217  SWIG_fail_ptr("Node_GetAttribute",1,SWIGTYPE_p_Mezzanine__XML__Node);
4218  }
4219 
4220  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
4221  result = ((Mezzanine::XML::Node const *)arg1)->GetAttribute((Mezzanine::Char8 const *)arg2);
4222  {
4224  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Attribute,1); SWIG_arg++;
4225  }
4226  return SWIG_arg;
4227 
4228  if(0) SWIG_fail;
4229 
4230 fail:
4231  lua_error(L);
4232  return SWIG_arg;
4233 }
4234 
4235 
4236 static int _wrap_Node_GetNextSibling__SWIG_1(lua_State* L) {
4237  int SWIG_arg = 0;
4239  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
4240  Mezzanine::XML::Node result;
4241 
4242  SWIG_check_num_args("Mezzanine::XML::Node::GetNextSibling",2,2)
4243  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::GetNextSibling",1,"Mezzanine::XML::Node const *");
4244  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::GetNextSibling",2,"Mezzanine::Char8 const *");
4245 
4246  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
4247  SWIG_fail_ptr("Node_GetNextSibling",1,SWIGTYPE_p_Mezzanine__XML__Node);
4248  }
4249 
4250  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
4251  result = ((Mezzanine::XML::Node const *)arg1)->GetNextSibling((Mezzanine::Char8 const *)arg2);
4252  {
4253  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
4254  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
4255  }
4256  return SWIG_arg;
4257 
4258  if(0) SWIG_fail;
4259 
4260 fail:
4261  lua_error(L);
4262  return SWIG_arg;
4263 }
4264 
4265 
4266 static int _wrap_Node_GetNextSibling(lua_State* L) {
4267  int argc;
4268  int argv[3]={
4269  1,2,3
4270  };
4271 
4272  argc = lua_gettop(L);
4273  if (argc == 1) {
4274  int _v;
4275  {
4276  void *ptr;
4277  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
4278  _v = 0;
4279  } else {
4280  _v = 1;
4281  }
4282  }
4283  if (_v) {
4284  return _wrap_Node_GetNextSibling__SWIG_0(L);
4285  }
4286  }
4287  if (argc == 2) {
4288  int _v;
4289  {
4290  void *ptr;
4291  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
4292  _v = 0;
4293  } else {
4294  _v = 1;
4295  }
4296  }
4297  if (_v) {
4298  {
4299  _v = SWIG_lua_isnilstring(L,argv[1]);
4300  }
4301  if (_v) {
4302  return _wrap_Node_GetNextSibling__SWIG_1(L);
4303  }
4304  }
4305  }
4306 
4307  lua_pushstring(L,"Wrong arguments for overloaded function 'Node_GetNextSibling'\n"
4308  " Possible C/C++ prototypes are:\n"
4309  " Mezzanine::XML::Node::GetNextSibling() const\n"
4310  " Mezzanine::XML::Node::GetNextSibling(Mezzanine::Char8 const *) const\n");
4311  lua_error(L);return 0;
4312 }
4313 
4314 
4315 static int _wrap_Node_GetPreviousSibling__SWIG_1(lua_State* L) {
4316  int SWIG_arg = 0;
4318  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
4319  Mezzanine::XML::Node result;
4320 
4321  SWIG_check_num_args("Mezzanine::XML::Node::GetPreviousSibling",2,2)
4322  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::GetPreviousSibling",1,"Mezzanine::XML::Node const *");
4323  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::GetPreviousSibling",2,"Mezzanine::Char8 const *");
4324 
4325  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
4326  SWIG_fail_ptr("Node_GetPreviousSibling",1,SWIGTYPE_p_Mezzanine__XML__Node);
4327  }
4328 
4329  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
4330  result = ((Mezzanine::XML::Node const *)arg1)->GetPreviousSibling((Mezzanine::Char8 const *)arg2);
4331  {
4332  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
4333  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
4334  }
4335  return SWIG_arg;
4336 
4337  if(0) SWIG_fail;
4338 
4339 fail:
4340  lua_error(L);
4341  return SWIG_arg;
4342 }
4343 
4344 
4345 static int _wrap_Node_GetPreviousSibling(lua_State* L) {
4346  int argc;
4347  int argv[3]={
4348  1,2,3
4349  };
4350 
4351  argc = lua_gettop(L);
4352  if (argc == 1) {
4353  int _v;
4354  {
4355  void *ptr;
4356  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
4357  _v = 0;
4358  } else {
4359  _v = 1;
4360  }
4361  }
4362  if (_v) {
4363  return _wrap_Node_GetPreviousSibling__SWIG_0(L);
4364  }
4365  }
4366  if (argc == 2) {
4367  int _v;
4368  {
4369  void *ptr;
4370  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
4371  _v = 0;
4372  } else {
4373  _v = 1;
4374  }
4375  }
4376  if (_v) {
4377  {
4378  _v = SWIG_lua_isnilstring(L,argv[1]);
4379  }
4380  if (_v) {
4381  return _wrap_Node_GetPreviousSibling__SWIG_1(L);
4382  }
4383  }
4384  }
4385 
4386  lua_pushstring(L,"Wrong arguments for overloaded function 'Node_GetPreviousSibling'\n"
4387  " Possible C/C++ prototypes are:\n"
4388  " Mezzanine::XML::Node::GetPreviousSibling() const\n"
4389  " Mezzanine::XML::Node::GetPreviousSibling(Mezzanine::Char8 const *) const\n");
4390  lua_error(L);return 0;
4391 }
4392 
4393 
4394 static int _wrap_Node_GetChildValue__SWIG_0(lua_State* L) {
4395  int SWIG_arg = 0;
4397  Mezzanine::Char8 *result = 0 ;
4398 
4399  SWIG_check_num_args("Mezzanine::XML::Node::GetChildValue",1,1)
4400  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::GetChildValue",1,"Mezzanine::XML::Node const *");
4401 
4402  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
4403  SWIG_fail_ptr("Node_GetChildValue",1,SWIGTYPE_p_Mezzanine__XML__Node);
4404  }
4405 
4406  result = (Mezzanine::Char8 *)((Mezzanine::XML::Node const *)arg1)->GetChildValue();
4407  lua_pushstring(L,(const char *)result); SWIG_arg++;
4408  return SWIG_arg;
4409 
4410  if(0) SWIG_fail;
4411 
4412 fail:
4413  lua_error(L);
4414  return SWIG_arg;
4415 }
4416 
4417 
4418 static int _wrap_Node_GetChildValue__SWIG_1(lua_State* L) {
4419  int SWIG_arg = 0;
4421  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
4422  Mezzanine::Char8 *result = 0 ;
4423 
4424  SWIG_check_num_args("Mezzanine::XML::Node::GetChildValue",2,2)
4425  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::GetChildValue",1,"Mezzanine::XML::Node const *");
4426  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::GetChildValue",2,"Mezzanine::Char8 const *");
4427 
4428  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
4429  SWIG_fail_ptr("Node_GetChildValue",1,SWIGTYPE_p_Mezzanine__XML__Node);
4430  }
4431 
4432  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
4433  result = (Mezzanine::Char8 *)((Mezzanine::XML::Node const *)arg1)->GetChildValue((Mezzanine::Char8 const *)arg2);
4434  lua_pushstring(L,(const char *)result); SWIG_arg++;
4435  return SWIG_arg;
4436 
4437  if(0) SWIG_fail;
4438 
4439 fail:
4440  lua_error(L);
4441  return SWIG_arg;
4442 }
4443 
4444 
4445 static int _wrap_Node_GetChildValue(lua_State* L) {
4446  int argc;
4447  int argv[3]={
4448  1,2,3
4449  };
4450 
4451  argc = lua_gettop(L);
4452  if (argc == 1) {
4453  int _v;
4454  {
4455  void *ptr;
4456  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
4457  _v = 0;
4458  } else {
4459  _v = 1;
4460  }
4461  }
4462  if (_v) {
4463  return _wrap_Node_GetChildValue__SWIG_0(L);
4464  }
4465  }
4466  if (argc == 2) {
4467  int _v;
4468  {
4469  void *ptr;
4470  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
4471  _v = 0;
4472  } else {
4473  _v = 1;
4474  }
4475  }
4476  if (_v) {
4477  {
4478  _v = SWIG_lua_isnilstring(L,argv[1]);
4479  }
4480  if (_v) {
4481  return _wrap_Node_GetChildValue__SWIG_1(L);
4482  }
4483  }
4484  }
4485 
4486  lua_pushstring(L,"Wrong arguments for overloaded function 'Node_GetChildValue'\n"
4487  " Possible C/C++ prototypes are:\n"
4488  " Mezzanine::XML::Node::GetChildValue() const\n"
4489  " Mezzanine::XML::Node::GetChildValue(Mezzanine::Char8 const *) const\n");
4490  lua_error(L);return 0;
4491 }
4492 
4493 
4494 static int _wrap_Node_SetName(lua_State* L) {
4495  int SWIG_arg = 0;
4497  Mezzanine::String *arg2 = 0 ;
4498  Mezzanine::String temp2 ;
4499  bool result;
4500 
4501  SWIG_check_num_args("Mezzanine::XML::Node::SetName",2,2)
4502  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::SetName",1,"Mezzanine::XML::Node *");
4503  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::SetName",2,"Mezzanine::String const &");
4504 
4505  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
4506  SWIG_fail_ptr("Node_SetName",1,SWIGTYPE_p_Mezzanine__XML__Node);
4507  }
4508 
4509  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
4510  result = (bool)(arg1)->SetName((Mezzanine::String const &)*arg2);
4511  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
4512  return SWIG_arg;
4513 
4514  if(0) SWIG_fail;
4515 
4516 fail:
4517  lua_error(L);
4518  return SWIG_arg;
4519 }
4520 
4521 
4522 static int _wrap_Node_SetValue(lua_State* L) {
4523  int SWIG_arg = 0;
4525  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
4526  bool result;
4527 
4528  SWIG_check_num_args("Mezzanine::XML::Node::SetValue",2,2)
4529  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::SetValue",1,"Mezzanine::XML::Node *");
4530  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::SetValue",2,"Mezzanine::Char8 const *");
4531 
4532  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
4533  SWIG_fail_ptr("Node_SetValue",1,SWIGTYPE_p_Mezzanine__XML__Node);
4534  }
4535 
4536  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
4537  result = (bool)(arg1)->SetValue((Mezzanine::Char8 const *)arg2);
4538  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
4539  return SWIG_arg;
4540 
4541  if(0) SWIG_fail;
4542 
4543 fail:
4544  lua_error(L);
4545  return SWIG_arg;
4546 }
4547 
4548 
4549 static int _wrap_Node_AppendAttribute(lua_State* L) {
4550  int SWIG_arg = 0;
4552  Mezzanine::String *arg2 = 0 ;
4553  Mezzanine::String temp2 ;
4555 
4556  SWIG_check_num_args("Mezzanine::XML::Node::AppendAttribute",2,2)
4557  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::AppendAttribute",1,"Mezzanine::XML::Node *");
4558  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::AppendAttribute",2,"Mezzanine::String const &");
4559 
4560  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
4561  SWIG_fail_ptr("Node_AppendAttribute",1,SWIGTYPE_p_Mezzanine__XML__Node);
4562  }
4563 
4564  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
4565  result = (arg1)->AppendAttribute((Mezzanine::String const &)*arg2);
4566  {
4568  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Attribute,1); SWIG_arg++;
4569  }
4570  return SWIG_arg;
4571 
4572  if(0) SWIG_fail;
4573 
4574 fail:
4575  lua_error(L);
4576  return SWIG_arg;
4577 }
4578 
4579 
4580 static int _wrap_Node_PrependAttribute(lua_State* L) {
4581  int SWIG_arg = 0;
4583  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
4585 
4586  SWIG_check_num_args("Mezzanine::XML::Node::PrependAttribute",2,2)
4587  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::PrependAttribute",1,"Mezzanine::XML::Node *");
4588  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::PrependAttribute",2,"Mezzanine::Char8 const *");
4589 
4590  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
4591  SWIG_fail_ptr("Node_PrependAttribute",1,SWIGTYPE_p_Mezzanine__XML__Node);
4592  }
4593 
4594  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
4595  result = (arg1)->PrependAttribute((Mezzanine::Char8 const *)arg2);
4596  {
4598  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Attribute,1); SWIG_arg++;
4599  }
4600  return SWIG_arg;
4601 
4602  if(0) SWIG_fail;
4603 
4604 fail:
4605  lua_error(L);
4606  return SWIG_arg;
4607 }
4608 
4609 
4610 static int _wrap_Node_InsertAttributeAfter(lua_State* L) {
4611  int SWIG_arg = 0;
4613  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
4614  Mezzanine::XML::Attribute *arg3 = 0 ;
4616 
4617  SWIG_check_num_args("Mezzanine::XML::Node::InsertAttributeAfter",3,3)
4618  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::InsertAttributeAfter",1,"Mezzanine::XML::Node *");
4619  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::InsertAttributeAfter",2,"Mezzanine::Char8 const *");
4620  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::InsertAttributeAfter",3,"Mezzanine::XML::Attribute const &");
4621 
4622  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
4623  SWIG_fail_ptr("Node_InsertAttributeAfter",1,SWIGTYPE_p_Mezzanine__XML__Node);
4624  }
4625 
4626  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
4627 
4628  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
4629  SWIG_fail_ptr("Node_InsertAttributeAfter",3,SWIGTYPE_p_Mezzanine__XML__Attribute);
4630  }
4631 
4632  result = (arg1)->InsertAttributeAfter((Mezzanine::Char8 const *)arg2,(Mezzanine::XML::Attribute const &)*arg3);
4633  {
4635  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Attribute,1); SWIG_arg++;
4636  }
4637  return SWIG_arg;
4638 
4639  if(0) SWIG_fail;
4640 
4641 fail:
4642  lua_error(L);
4643  return SWIG_arg;
4644 }
4645 
4646 
4647 static int _wrap_Node_InsertAttributeBefore(lua_State* L) {
4648  int SWIG_arg = 0;
4650  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
4651  Mezzanine::XML::Attribute *arg3 = 0 ;
4653 
4654  SWIG_check_num_args("Mezzanine::XML::Node::InsertAttributeBefore",3,3)
4655  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::InsertAttributeBefore",1,"Mezzanine::XML::Node *");
4656  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::InsertAttributeBefore",2,"Mezzanine::Char8 const *");
4657  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::InsertAttributeBefore",3,"Mezzanine::XML::Attribute const &");
4658 
4659  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
4660  SWIG_fail_ptr("Node_InsertAttributeBefore",1,SWIGTYPE_p_Mezzanine__XML__Node);
4661  }
4662 
4663  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
4664 
4665  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
4666  SWIG_fail_ptr("Node_InsertAttributeBefore",3,SWIGTYPE_p_Mezzanine__XML__Attribute);
4667  }
4668 
4669  result = (arg1)->InsertAttributeBefore((Mezzanine::Char8 const *)arg2,(Mezzanine::XML::Attribute const &)*arg3);
4670  {
4672  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Attribute,1); SWIG_arg++;
4673  }
4674  return SWIG_arg;
4675 
4676  if(0) SWIG_fail;
4677 
4678 fail:
4679  lua_error(L);
4680  return SWIG_arg;
4681 }
4682 
4683 
4684 static int _wrap_Node_AppendCopy__SWIG_0(lua_State* L) {
4685  int SWIG_arg = 0;
4687  Mezzanine::XML::Attribute *arg2 = 0 ;
4689 
4690  SWIG_check_num_args("Mezzanine::XML::Node::AppendCopy",2,2)
4691  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::AppendCopy",1,"Mezzanine::XML::Node *");
4692  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::AppendCopy",2,"Mezzanine::XML::Attribute const &");
4693 
4694  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
4695  SWIG_fail_ptr("Node_AppendCopy",1,SWIGTYPE_p_Mezzanine__XML__Node);
4696  }
4697 
4698 
4699  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
4700  SWIG_fail_ptr("Node_AppendCopy",2,SWIGTYPE_p_Mezzanine__XML__Attribute);
4701  }
4702 
4703  result = (arg1)->AppendCopy((Mezzanine::XML::Attribute const &)*arg2);
4704  {
4706  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Attribute,1); SWIG_arg++;
4707  }
4708  return SWIG_arg;
4709 
4710  if(0) SWIG_fail;
4711 
4712 fail:
4713  lua_error(L);
4714  return SWIG_arg;
4715 }
4716 
4717 
4718 static int _wrap_Node_PrependCopy__SWIG_0(lua_State* L) {
4719  int SWIG_arg = 0;
4721  Mezzanine::XML::Attribute *arg2 = 0 ;
4723 
4724  SWIG_check_num_args("Mezzanine::XML::Node::PrependCopy",2,2)
4725  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::PrependCopy",1,"Mezzanine::XML::Node *");
4726  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::PrependCopy",2,"Mezzanine::XML::Attribute const &");
4727 
4728  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
4729  SWIG_fail_ptr("Node_PrependCopy",1,SWIGTYPE_p_Mezzanine__XML__Node);
4730  }
4731 
4732 
4733  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
4734  SWIG_fail_ptr("Node_PrependCopy",2,SWIGTYPE_p_Mezzanine__XML__Attribute);
4735  }
4736 
4737  result = (arg1)->PrependCopy((Mezzanine::XML::Attribute const &)*arg2);
4738  {
4740  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Attribute,1); SWIG_arg++;
4741  }
4742  return SWIG_arg;
4743 
4744  if(0) SWIG_fail;
4745 
4746 fail:
4747  lua_error(L);
4748  return SWIG_arg;
4749 }
4750 
4751 
4752 static int _wrap_Node_InsertCopyAfter__SWIG_0(lua_State* L) {
4753  int SWIG_arg = 0;
4755  Mezzanine::XML::Attribute *arg2 = 0 ;
4756  Mezzanine::XML::Attribute *arg3 = 0 ;
4758 
4759  SWIG_check_num_args("Mezzanine::XML::Node::InsertCopyAfter",3,3)
4760  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::InsertCopyAfter",1,"Mezzanine::XML::Node *");
4761  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::InsertCopyAfter",2,"Mezzanine::XML::Attribute const &");
4762  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::InsertCopyAfter",3,"Mezzanine::XML::Attribute const &");
4763 
4764  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
4765  SWIG_fail_ptr("Node_InsertCopyAfter",1,SWIGTYPE_p_Mezzanine__XML__Node);
4766  }
4767 
4768 
4769  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
4770  SWIG_fail_ptr("Node_InsertCopyAfter",2,SWIGTYPE_p_Mezzanine__XML__Attribute);
4771  }
4772 
4773 
4774  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
4775  SWIG_fail_ptr("Node_InsertCopyAfter",3,SWIGTYPE_p_Mezzanine__XML__Attribute);
4776  }
4777 
4778  result = (arg1)->InsertCopyAfter((Mezzanine::XML::Attribute const &)*arg2,(Mezzanine::XML::Attribute const &)*arg3);
4779  {
4781  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Attribute,1); SWIG_arg++;
4782  }
4783  return SWIG_arg;
4784 
4785  if(0) SWIG_fail;
4786 
4787 fail:
4788  lua_error(L);
4789  return SWIG_arg;
4790 }
4791 
4792 
4793 static int _wrap_Node_InsertCopyBefore__SWIG_0(lua_State* L) {
4794  int SWIG_arg = 0;
4796  Mezzanine::XML::Attribute *arg2 = 0 ;
4797  Mezzanine::XML::Attribute *arg3 = 0 ;
4799 
4800  SWIG_check_num_args("Mezzanine::XML::Node::InsertCopyBefore",3,3)
4801  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::InsertCopyBefore",1,"Mezzanine::XML::Node *");
4802  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::InsertCopyBefore",2,"Mezzanine::XML::Attribute const &");
4803  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::InsertCopyBefore",3,"Mezzanine::XML::Attribute const &");
4804 
4805  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
4806  SWIG_fail_ptr("Node_InsertCopyBefore",1,SWIGTYPE_p_Mezzanine__XML__Node);
4807  }
4808 
4809 
4810  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
4811  SWIG_fail_ptr("Node_InsertCopyBefore",2,SWIGTYPE_p_Mezzanine__XML__Attribute);
4812  }
4813 
4814 
4815  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
4816  SWIG_fail_ptr("Node_InsertCopyBefore",3,SWIGTYPE_p_Mezzanine__XML__Attribute);
4817  }
4818 
4819  result = (arg1)->InsertCopyBefore((Mezzanine::XML::Attribute const &)*arg2,(Mezzanine::XML::Attribute const &)*arg3);
4820  {
4822  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Attribute,1); SWIG_arg++;
4823  }
4824  return SWIG_arg;
4825 
4826  if(0) SWIG_fail;
4827 
4828 fail:
4829  lua_error(L);
4830  return SWIG_arg;
4831 }
4832 
4833 
4834 static int _wrap_Node_AppendChild__SWIG_0(lua_State* L) {
4835  int SWIG_arg = 0;
4838  Mezzanine::XML::Node result;
4839 
4840  SWIG_check_num_args("Mezzanine::XML::Node::AppendChild",2,2)
4841  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::AppendChild",1,"Mezzanine::XML::Node *");
4842  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::AppendChild",2,"Mezzanine::XML::NodeType");
4843 
4844  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
4845  SWIG_fail_ptr("Node_AppendChild",1,SWIGTYPE_p_Mezzanine__XML__Node);
4846  }
4847 
4848  arg2 = (Mezzanine::XML::NodeType)(int)lua_tonumber(L, 2);
4849  result = (arg1)->AppendChild(arg2);
4850  {
4851  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
4852  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
4853  }
4854  return SWIG_arg;
4855 
4856  if(0) SWIG_fail;
4857 
4858 fail:
4859  lua_error(L);
4860  return SWIG_arg;
4861 }
4862 
4863 
4864 static int _wrap_Node_AppendChild__SWIG_1(lua_State* L) {
4865  int SWIG_arg = 0;
4867  Mezzanine::XML::Node result;
4868 
4869  SWIG_check_num_args("Mezzanine::XML::Node::AppendChild",1,1)
4870  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::AppendChild",1,"Mezzanine::XML::Node *");
4871 
4872  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
4873  SWIG_fail_ptr("Node_AppendChild",1,SWIGTYPE_p_Mezzanine__XML__Node);
4874  }
4875 
4876  result = (arg1)->AppendChild();
4877  {
4878  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
4879  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
4880  }
4881  return SWIG_arg;
4882 
4883  if(0) SWIG_fail;
4884 
4885 fail:
4886  lua_error(L);
4887  return SWIG_arg;
4888 }
4889 
4890 
4891 static int _wrap_Node_PrependChild__SWIG_0(lua_State* L) {
4892  int SWIG_arg = 0;
4895  Mezzanine::XML::Node result;
4896 
4897  SWIG_check_num_args("Mezzanine::XML::Node::PrependChild",2,2)
4898  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::PrependChild",1,"Mezzanine::XML::Node *");
4899  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::PrependChild",2,"Mezzanine::XML::NodeType");
4900 
4901  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
4902  SWIG_fail_ptr("Node_PrependChild",1,SWIGTYPE_p_Mezzanine__XML__Node);
4903  }
4904 
4905  arg2 = (Mezzanine::XML::NodeType)(int)lua_tonumber(L, 2);
4906  result = (arg1)->PrependChild(arg2);
4907  {
4908  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
4909  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
4910  }
4911  return SWIG_arg;
4912 
4913  if(0) SWIG_fail;
4914 
4915 fail:
4916  lua_error(L);
4917  return SWIG_arg;
4918 }
4919 
4920 
4921 static int _wrap_Node_PrependChild__SWIG_1(lua_State* L) {
4922  int SWIG_arg = 0;
4924  Mezzanine::XML::Node result;
4925 
4926  SWIG_check_num_args("Mezzanine::XML::Node::PrependChild",1,1)
4927  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::PrependChild",1,"Mezzanine::XML::Node *");
4928 
4929  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
4930  SWIG_fail_ptr("Node_PrependChild",1,SWIGTYPE_p_Mezzanine__XML__Node);
4931  }
4932 
4933  result = (arg1)->PrependChild();
4934  {
4935  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
4936  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
4937  }
4938  return SWIG_arg;
4939 
4940  if(0) SWIG_fail;
4941 
4942 fail:
4943  lua_error(L);
4944  return SWIG_arg;
4945 }
4946 
4947 
4948 static int _wrap_Node_InsertChildAfter__SWIG_0(lua_State* L) {
4949  int SWIG_arg = 0;
4952  Mezzanine::XML::Node *arg3 = 0 ;
4953  Mezzanine::XML::Node result;
4954 
4955  SWIG_check_num_args("Mezzanine::XML::Node::InsertChildAfter",3,3)
4956  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::InsertChildAfter",1,"Mezzanine::XML::Node *");
4957  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::InsertChildAfter",2,"Mezzanine::XML::NodeType");
4958  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::InsertChildAfter",3,"Mezzanine::XML::Node const &");
4959 
4960  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
4961  SWIG_fail_ptr("Node_InsertChildAfter",1,SWIGTYPE_p_Mezzanine__XML__Node);
4962  }
4963 
4964  arg2 = (Mezzanine::XML::NodeType)(int)lua_tonumber(L, 2);
4965 
4966  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__XML__Node,0))){
4967  SWIG_fail_ptr("Node_InsertChildAfter",3,SWIGTYPE_p_Mezzanine__XML__Node);
4968  }
4969 
4970  result = (arg1)->InsertChildAfter(arg2,(Mezzanine::XML::Node const &)*arg3);
4971  {
4972  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
4973  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
4974  }
4975  return SWIG_arg;
4976 
4977  if(0) SWIG_fail;
4978 
4979 fail:
4980  lua_error(L);
4981  return SWIG_arg;
4982 }
4983 
4984 
4985 static int _wrap_Node_InsertChildBefore__SWIG_0(lua_State* L) {
4986  int SWIG_arg = 0;
4989  Mezzanine::XML::Node *arg3 = 0 ;
4990  Mezzanine::XML::Node result;
4991 
4992  SWIG_check_num_args("Mezzanine::XML::Node::InsertChildBefore",3,3)
4993  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::InsertChildBefore",1,"Mezzanine::XML::Node *");
4994  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::InsertChildBefore",2,"Mezzanine::XML::NodeType");
4995  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::InsertChildBefore",3,"Mezzanine::XML::Node const &");
4996 
4997  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
4998  SWIG_fail_ptr("Node_InsertChildBefore",1,SWIGTYPE_p_Mezzanine__XML__Node);
4999  }
5000 
5001  arg2 = (Mezzanine::XML::NodeType)(int)lua_tonumber(L, 2);
5002 
5003  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__XML__Node,0))){
5004  SWIG_fail_ptr("Node_InsertChildBefore",3,SWIGTYPE_p_Mezzanine__XML__Node);
5005  }
5006 
5007  result = (arg1)->InsertChildBefore(arg2,(Mezzanine::XML::Node const &)*arg3);
5008  {
5009  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
5010  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
5011  }
5012  return SWIG_arg;
5013 
5014  if(0) SWIG_fail;
5015 
5016 fail:
5017  lua_error(L);
5018  return SWIG_arg;
5019 }
5020 
5021 
5022 static int _wrap_Node_AppendChild__SWIG_2(lua_State* L) {
5023  int SWIG_arg = 0;
5025  Mezzanine::String *arg2 = 0 ;
5026  Mezzanine::String temp2 ;
5027  Mezzanine::XML::Node result;
5028 
5029  SWIG_check_num_args("Mezzanine::XML::Node::AppendChild",2,2)
5030  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::AppendChild",1,"Mezzanine::XML::Node *");
5031  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::AppendChild",2,"Mezzanine::String const &");
5032 
5033  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
5034  SWIG_fail_ptr("Node_AppendChild",1,SWIGTYPE_p_Mezzanine__XML__Node);
5035  }
5036 
5037  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
5038  result = (arg1)->AppendChild((Mezzanine::String const &)*arg2);
5039  {
5040  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
5041  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
5042  }
5043  return SWIG_arg;
5044 
5045  if(0) SWIG_fail;
5046 
5047 fail:
5048  lua_error(L);
5049  return SWIG_arg;
5050 }
5051 
5052 
5053 static int _wrap_Node_AppendChild(lua_State* L) {
5054  int argc;
5055  int argv[3]={
5056  1,2,3
5057  };
5058 
5059  argc = lua_gettop(L);
5060  if (argc == 1) {
5061  int _v;
5062  {
5063  void *ptr;
5064  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
5065  _v = 0;
5066  } else {
5067  _v = 1;
5068  }
5069  }
5070  if (_v) {
5071  return _wrap_Node_AppendChild__SWIG_1(L);
5072  }
5073  }
5074  if (argc == 2) {
5075  int _v;
5076  {
5077  void *ptr;
5078  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
5079  _v = 0;
5080  } else {
5081  _v = 1;
5082  }
5083  }
5084  if (_v) {
5085  {
5086  _v = lua_isnumber(L,argv[1]);
5087  }
5088  if (_v) {
5089  return _wrap_Node_AppendChild__SWIG_0(L);
5090  }
5091  }
5092  }
5093  if (argc == 2) {
5094  int _v;
5095  {
5096  void *ptr;
5097  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
5098  _v = 0;
5099  } else {
5100  _v = 1;
5101  }
5102  }
5103  if (_v) {
5104  {
5105  _v = lua_isstring(L,argv[1]);
5106  }
5107  if (_v) {
5108  return _wrap_Node_AppendChild__SWIG_2(L);
5109  }
5110  }
5111  }
5112 
5113  lua_pushstring(L,"Wrong arguments for overloaded function 'Node_AppendChild'\n"
5114  " Possible C/C++ prototypes are:\n"
5115  " Mezzanine::XML::Node::AppendChild(Mezzanine::XML::NodeType)\n"
5116  " Mezzanine::XML::Node::AppendChild()\n"
5117  " Mezzanine::XML::Node::AppendChild(Mezzanine::String const &)\n");
5118  lua_error(L);return 0;
5119 }
5120 
5121 
5122 static int _wrap_Node_PrependChild__SWIG_2(lua_State* L) {
5123  int SWIG_arg = 0;
5125  Mezzanine::String *arg2 = 0 ;
5126  Mezzanine::String temp2 ;
5127  Mezzanine::XML::Node result;
5128 
5129  SWIG_check_num_args("Mezzanine::XML::Node::PrependChild",2,2)
5130  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::PrependChild",1,"Mezzanine::XML::Node *");
5131  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::PrependChild",2,"Mezzanine::String const &");
5132 
5133  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
5134  SWIG_fail_ptr("Node_PrependChild",1,SWIGTYPE_p_Mezzanine__XML__Node);
5135  }
5136 
5137  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
5138  result = (arg1)->PrependChild((Mezzanine::String const &)*arg2);
5139  {
5140  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
5141  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
5142  }
5143  return SWIG_arg;
5144 
5145  if(0) SWIG_fail;
5146 
5147 fail:
5148  lua_error(L);
5149  return SWIG_arg;
5150 }
5151 
5152 
5153 static int _wrap_Node_PrependChild(lua_State* L) {
5154  int argc;
5155  int argv[3]={
5156  1,2,3
5157  };
5158 
5159  argc = lua_gettop(L);
5160  if (argc == 1) {
5161  int _v;
5162  {
5163  void *ptr;
5164  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
5165  _v = 0;
5166  } else {
5167  _v = 1;
5168  }
5169  }
5170  if (_v) {
5171  return _wrap_Node_PrependChild__SWIG_1(L);
5172  }
5173  }
5174  if (argc == 2) {
5175  int _v;
5176  {
5177  void *ptr;
5178  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
5179  _v = 0;
5180  } else {
5181  _v = 1;
5182  }
5183  }
5184  if (_v) {
5185  {
5186  _v = lua_isnumber(L,argv[1]);
5187  }
5188  if (_v) {
5189  return _wrap_Node_PrependChild__SWIG_0(L);
5190  }
5191  }
5192  }
5193  if (argc == 2) {
5194  int _v;
5195  {
5196  void *ptr;
5197  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
5198  _v = 0;
5199  } else {
5200  _v = 1;
5201  }
5202  }
5203  if (_v) {
5204  {
5205  _v = lua_isstring(L,argv[1]);
5206  }
5207  if (_v) {
5208  return _wrap_Node_PrependChild__SWIG_2(L);
5209  }
5210  }
5211  }
5212 
5213  lua_pushstring(L,"Wrong arguments for overloaded function 'Node_PrependChild'\n"
5214  " Possible C/C++ prototypes are:\n"
5215  " Mezzanine::XML::Node::PrependChild(Mezzanine::XML::NodeType)\n"
5216  " Mezzanine::XML::Node::PrependChild()\n"
5217  " Mezzanine::XML::Node::PrependChild(Mezzanine::String const &)\n");
5218  lua_error(L);return 0;
5219 }
5220 
5221 
5222 static int _wrap_Node_InsertChildAfter__SWIG_1(lua_State* L) {
5223  int SWIG_arg = 0;
5225  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
5226  Mezzanine::XML::Node *arg3 = 0 ;
5227  Mezzanine::XML::Node result;
5228 
5229  SWIG_check_num_args("Mezzanine::XML::Node::InsertChildAfter",3,3)
5230  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::InsertChildAfter",1,"Mezzanine::XML::Node *");
5231  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::InsertChildAfter",2,"Mezzanine::Char8 const *");
5232  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::InsertChildAfter",3,"Mezzanine::XML::Node const &");
5233 
5234  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
5235  SWIG_fail_ptr("Node_InsertChildAfter",1,SWIGTYPE_p_Mezzanine__XML__Node);
5236  }
5237 
5238  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
5239 
5240  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__XML__Node,0))){
5241  SWIG_fail_ptr("Node_InsertChildAfter",3,SWIGTYPE_p_Mezzanine__XML__Node);
5242  }
5243 
5244  result = (arg1)->InsertChildAfter((Mezzanine::Char8 const *)arg2,(Mezzanine::XML::Node const &)*arg3);
5245  {
5246  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
5247  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
5248  }
5249  return SWIG_arg;
5250 
5251  if(0) SWIG_fail;
5252 
5253 fail:
5254  lua_error(L);
5255  return SWIG_arg;
5256 }
5257 
5258 
5259 static int _wrap_Node_InsertChildAfter(lua_State* L) {
5260  int argc;
5261  int argv[4]={
5262  1,2,3,4
5263  };
5264 
5265  argc = lua_gettop(L);
5266  if (argc == 3) {
5267  int _v;
5268  {
5269  void *ptr;
5270  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
5271  _v = 0;
5272  } else {
5273  _v = 1;
5274  }
5275  }
5276  if (_v) {
5277  {
5278  _v = lua_isnumber(L,argv[1]);
5279  }
5280  if (_v) {
5281  {
5282  void *ptr;
5283  if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
5284  _v = 0;
5285  } else {
5286  _v = 1;
5287  }
5288  }
5289  if (_v) {
5290  return _wrap_Node_InsertChildAfter__SWIG_0(L);
5291  }
5292  }
5293  }
5294  }
5295  if (argc == 3) {
5296  int _v;
5297  {
5298  void *ptr;
5299  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
5300  _v = 0;
5301  } else {
5302  _v = 1;
5303  }
5304  }
5305  if (_v) {
5306  {
5307  _v = SWIG_lua_isnilstring(L,argv[1]);
5308  }
5309  if (_v) {
5310  {
5311  void *ptr;
5312  if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
5313  _v = 0;
5314  } else {
5315  _v = 1;
5316  }
5317  }
5318  if (_v) {
5319  return _wrap_Node_InsertChildAfter__SWIG_1(L);
5320  }
5321  }
5322  }
5323  }
5324 
5325  lua_pushstring(L,"Wrong arguments for overloaded function 'Node_InsertChildAfter'\n"
5326  " Possible C/C++ prototypes are:\n"
5327  " Mezzanine::XML::Node::InsertChildAfter(Mezzanine::XML::NodeType,Mezzanine::XML::Node const &)\n"
5328  " Mezzanine::XML::Node::InsertChildAfter(Mezzanine::Char8 const *,Mezzanine::XML::Node const &)\n");
5329  lua_error(L);return 0;
5330 }
5331 
5332 
5333 static int _wrap_Node_InsertChildBefore__SWIG_1(lua_State* L) {
5334  int SWIG_arg = 0;
5336  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
5337  Mezzanine::XML::Node *arg3 = 0 ;
5338  Mezzanine::XML::Node result;
5339 
5340  SWIG_check_num_args("Mezzanine::XML::Node::InsertChildBefore",3,3)
5341  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::InsertChildBefore",1,"Mezzanine::XML::Node *");
5342  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::InsertChildBefore",2,"Mezzanine::Char8 const *");
5343  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::InsertChildBefore",3,"Mezzanine::XML::Node const &");
5344 
5345  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
5346  SWIG_fail_ptr("Node_InsertChildBefore",1,SWIGTYPE_p_Mezzanine__XML__Node);
5347  }
5348 
5349  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
5350 
5351  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__XML__Node,0))){
5352  SWIG_fail_ptr("Node_InsertChildBefore",3,SWIGTYPE_p_Mezzanine__XML__Node);
5353  }
5354 
5355  result = (arg1)->InsertChildBefore((Mezzanine::Char8 const *)arg2,(Mezzanine::XML::Node const &)*arg3);
5356  {
5357  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
5358  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
5359  }
5360  return SWIG_arg;
5361 
5362  if(0) SWIG_fail;
5363 
5364 fail:
5365  lua_error(L);
5366  return SWIG_arg;
5367 }
5368 
5369 
5370 static int _wrap_Node_InsertChildBefore(lua_State* L) {
5371  int argc;
5372  int argv[4]={
5373  1,2,3,4
5374  };
5375 
5376  argc = lua_gettop(L);
5377  if (argc == 3) {
5378  int _v;
5379  {
5380  void *ptr;
5381  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
5382  _v = 0;
5383  } else {
5384  _v = 1;
5385  }
5386  }
5387  if (_v) {
5388  {
5389  _v = lua_isnumber(L,argv[1]);
5390  }
5391  if (_v) {
5392  {
5393  void *ptr;
5394  if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
5395  _v = 0;
5396  } else {
5397  _v = 1;
5398  }
5399  }
5400  if (_v) {
5401  return _wrap_Node_InsertChildBefore__SWIG_0(L);
5402  }
5403  }
5404  }
5405  }
5406  if (argc == 3) {
5407  int _v;
5408  {
5409  void *ptr;
5410  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
5411  _v = 0;
5412  } else {
5413  _v = 1;
5414  }
5415  }
5416  if (_v) {
5417  {
5418  _v = SWIG_lua_isnilstring(L,argv[1]);
5419  }
5420  if (_v) {
5421  {
5422  void *ptr;
5423  if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
5424  _v = 0;
5425  } else {
5426  _v = 1;
5427  }
5428  }
5429  if (_v) {
5430  return _wrap_Node_InsertChildBefore__SWIG_1(L);
5431  }
5432  }
5433  }
5434  }
5435 
5436  lua_pushstring(L,"Wrong arguments for overloaded function 'Node_InsertChildBefore'\n"
5437  " Possible C/C++ prototypes are:\n"
5438  " Mezzanine::XML::Node::InsertChildBefore(Mezzanine::XML::NodeType,Mezzanine::XML::Node const &)\n"
5439  " Mezzanine::XML::Node::InsertChildBefore(Mezzanine::Char8 const *,Mezzanine::XML::Node const &)\n");
5440  lua_error(L);return 0;
5441 }
5442 
5443 
5444 static int _wrap_Node_AppendCopy__SWIG_1(lua_State* L) {
5445  int SWIG_arg = 0;
5447  Mezzanine::XML::Node *arg2 = 0 ;
5448  Mezzanine::XML::Node result;
5449 
5450  SWIG_check_num_args("Mezzanine::XML::Node::AppendCopy",2,2)
5451  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::AppendCopy",1,"Mezzanine::XML::Node *");
5452  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::AppendCopy",2,"Mezzanine::XML::Node const &");
5453 
5454  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
5455  SWIG_fail_ptr("Node_AppendCopy",1,SWIGTYPE_p_Mezzanine__XML__Node);
5456  }
5457 
5458 
5459  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Node,0))){
5460  SWIG_fail_ptr("Node_AppendCopy",2,SWIGTYPE_p_Mezzanine__XML__Node);
5461  }
5462 
5463  result = (arg1)->AppendCopy((Mezzanine::XML::Node const &)*arg2);
5464  {
5465  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
5466  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
5467  }
5468  return SWIG_arg;
5469 
5470  if(0) SWIG_fail;
5471 
5472 fail:
5473  lua_error(L);
5474  return SWIG_arg;
5475 }
5476 
5477 
5478 static int _wrap_Node_AppendCopy(lua_State* L) {
5479  int argc;
5480  int argv[3]={
5481  1,2,3
5482  };
5483 
5484  argc = lua_gettop(L);
5485  if (argc == 2) {
5486  int _v;
5487  {
5488  void *ptr;
5489  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
5490  _v = 0;
5491  } else {
5492  _v = 1;
5493  }
5494  }
5495  if (_v) {
5496  {
5497  void *ptr;
5498  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Attribute, 0)) {
5499  _v = 0;
5500  } else {
5501  _v = 1;
5502  }
5503  }
5504  if (_v) {
5505  return _wrap_Node_AppendCopy__SWIG_0(L);
5506  }
5507  }
5508  }
5509  if (argc == 2) {
5510  int _v;
5511  {
5512  void *ptr;
5513  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
5514  _v = 0;
5515  } else {
5516  _v = 1;
5517  }
5518  }
5519  if (_v) {
5520  {
5521  void *ptr;
5522  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
5523  _v = 0;
5524  } else {
5525  _v = 1;
5526  }
5527  }
5528  if (_v) {
5529  return _wrap_Node_AppendCopy__SWIG_1(L);
5530  }
5531  }
5532  }
5533 
5534  lua_pushstring(L,"Wrong arguments for overloaded function 'Node_AppendCopy'\n"
5535  " Possible C/C++ prototypes are:\n"
5536  " Mezzanine::XML::Node::AppendCopy(Mezzanine::XML::Attribute const &)\n"
5537  " Mezzanine::XML::Node::AppendCopy(Mezzanine::XML::Node const &)\n");
5538  lua_error(L);return 0;
5539 }
5540 
5541 
5542 static int _wrap_Node_PrependCopy__SWIG_1(lua_State* L) {
5543  int SWIG_arg = 0;
5545  Mezzanine::XML::Node *arg2 = 0 ;
5546  Mezzanine::XML::Node result;
5547 
5548  SWIG_check_num_args("Mezzanine::XML::Node::PrependCopy",2,2)
5549  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::PrependCopy",1,"Mezzanine::XML::Node *");
5550  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::PrependCopy",2,"Mezzanine::XML::Node const &");
5551 
5552  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
5553  SWIG_fail_ptr("Node_PrependCopy",1,SWIGTYPE_p_Mezzanine__XML__Node);
5554  }
5555 
5556 
5557  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Node,0))){
5558  SWIG_fail_ptr("Node_PrependCopy",2,SWIGTYPE_p_Mezzanine__XML__Node);
5559  }
5560 
5561  result = (arg1)->PrependCopy((Mezzanine::XML::Node const &)*arg2);
5562  {
5563  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
5564  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
5565  }
5566  return SWIG_arg;
5567 
5568  if(0) SWIG_fail;
5569 
5570 fail:
5571  lua_error(L);
5572  return SWIG_arg;
5573 }
5574 
5575 
5576 static int _wrap_Node_PrependCopy(lua_State* L) {
5577  int argc;
5578  int argv[3]={
5579  1,2,3
5580  };
5581 
5582  argc = lua_gettop(L);
5583  if (argc == 2) {
5584  int _v;
5585  {
5586  void *ptr;
5587  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
5588  _v = 0;
5589  } else {
5590  _v = 1;
5591  }
5592  }
5593  if (_v) {
5594  {
5595  void *ptr;
5596  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Attribute, 0)) {
5597  _v = 0;
5598  } else {
5599  _v = 1;
5600  }
5601  }
5602  if (_v) {
5603  return _wrap_Node_PrependCopy__SWIG_0(L);
5604  }
5605  }
5606  }
5607  if (argc == 2) {
5608  int _v;
5609  {
5610  void *ptr;
5611  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
5612  _v = 0;
5613  } else {
5614  _v = 1;
5615  }
5616  }
5617  if (_v) {
5618  {
5619  void *ptr;
5620  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
5621  _v = 0;
5622  } else {
5623  _v = 1;
5624  }
5625  }
5626  if (_v) {
5627  return _wrap_Node_PrependCopy__SWIG_1(L);
5628  }
5629  }
5630  }
5631 
5632  lua_pushstring(L,"Wrong arguments for overloaded function 'Node_PrependCopy'\n"
5633  " Possible C/C++ prototypes are:\n"
5634  " Mezzanine::XML::Node::PrependCopy(Mezzanine::XML::Attribute const &)\n"
5635  " Mezzanine::XML::Node::PrependCopy(Mezzanine::XML::Node const &)\n");
5636  lua_error(L);return 0;
5637 }
5638 
5639 
5640 static int _wrap_Node_InsertCopyAfter__SWIG_1(lua_State* L) {
5641  int SWIG_arg = 0;
5643  Mezzanine::XML::Node *arg2 = 0 ;
5644  Mezzanine::XML::Node *arg3 = 0 ;
5645  Mezzanine::XML::Node result;
5646 
5647  SWIG_check_num_args("Mezzanine::XML::Node::InsertCopyAfter",3,3)
5648  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::InsertCopyAfter",1,"Mezzanine::XML::Node *");
5649  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::InsertCopyAfter",2,"Mezzanine::XML::Node const &");
5650  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::InsertCopyAfter",3,"Mezzanine::XML::Node const &");
5651 
5652  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
5653  SWIG_fail_ptr("Node_InsertCopyAfter",1,SWIGTYPE_p_Mezzanine__XML__Node);
5654  }
5655 
5656 
5657  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Node,0))){
5658  SWIG_fail_ptr("Node_InsertCopyAfter",2,SWIGTYPE_p_Mezzanine__XML__Node);
5659  }
5660 
5661 
5662  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__XML__Node,0))){
5663  SWIG_fail_ptr("Node_InsertCopyAfter",3,SWIGTYPE_p_Mezzanine__XML__Node);
5664  }
5665 
5666  result = (arg1)->InsertCopyAfter((Mezzanine::XML::Node const &)*arg2,(Mezzanine::XML::Node const &)*arg3);
5667  {
5668  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
5669  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
5670  }
5671  return SWIG_arg;
5672 
5673  if(0) SWIG_fail;
5674 
5675 fail:
5676  lua_error(L);
5677  return SWIG_arg;
5678 }
5679 
5680 
5681 static int _wrap_Node_InsertCopyAfter(lua_State* L) {
5682  int argc;
5683  int argv[4]={
5684  1,2,3,4
5685  };
5686 
5687  argc = lua_gettop(L);
5688  if (argc == 3) {
5689  int _v;
5690  {
5691  void *ptr;
5692  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
5693  _v = 0;
5694  } else {
5695  _v = 1;
5696  }
5697  }
5698  if (_v) {
5699  {
5700  void *ptr;
5701  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Attribute, 0)) {
5702  _v = 0;
5703  } else {
5704  _v = 1;
5705  }
5706  }
5707  if (_v) {
5708  {
5709  void *ptr;
5710  if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Attribute, 0)) {
5711  _v = 0;
5712  } else {
5713  _v = 1;
5714  }
5715  }
5716  if (_v) {
5717  return _wrap_Node_InsertCopyAfter__SWIG_0(L);
5718  }
5719  }
5720  }
5721  }
5722  if (argc == 3) {
5723  int _v;
5724  {
5725  void *ptr;
5726  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
5727  _v = 0;
5728  } else {
5729  _v = 1;
5730  }
5731  }
5732  if (_v) {
5733  {
5734  void *ptr;
5735  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
5736  _v = 0;
5737  } else {
5738  _v = 1;
5739  }
5740  }
5741  if (_v) {
5742  {
5743  void *ptr;
5744  if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
5745  _v = 0;
5746  } else {
5747  _v = 1;
5748  }
5749  }
5750  if (_v) {
5751  return _wrap_Node_InsertCopyAfter__SWIG_1(L);
5752  }
5753  }
5754  }
5755  }
5756 
5757  lua_pushstring(L,"Wrong arguments for overloaded function 'Node_InsertCopyAfter'\n"
5758  " Possible C/C++ prototypes are:\n"
5759  " Mezzanine::XML::Node::InsertCopyAfter(Mezzanine::XML::Attribute const &,Mezzanine::XML::Attribute const &)\n"
5760  " Mezzanine::XML::Node::InsertCopyAfter(Mezzanine::XML::Node const &,Mezzanine::XML::Node const &)\n");
5761  lua_error(L);return 0;
5762 }
5763 
5764 
5765 static int _wrap_Node_InsertCopyBefore__SWIG_1(lua_State* L) {
5766  int SWIG_arg = 0;
5768  Mezzanine::XML::Node *arg2 = 0 ;
5769  Mezzanine::XML::Node *arg3 = 0 ;
5770  Mezzanine::XML::Node result;
5771 
5772  SWIG_check_num_args("Mezzanine::XML::Node::InsertCopyBefore",3,3)
5773  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::InsertCopyBefore",1,"Mezzanine::XML::Node *");
5774  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::InsertCopyBefore",2,"Mezzanine::XML::Node const &");
5775  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::InsertCopyBefore",3,"Mezzanine::XML::Node const &");
5776 
5777  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
5778  SWIG_fail_ptr("Node_InsertCopyBefore",1,SWIGTYPE_p_Mezzanine__XML__Node);
5779  }
5780 
5781 
5782  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Node,0))){
5783  SWIG_fail_ptr("Node_InsertCopyBefore",2,SWIGTYPE_p_Mezzanine__XML__Node);
5784  }
5785 
5786 
5787  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__XML__Node,0))){
5788  SWIG_fail_ptr("Node_InsertCopyBefore",3,SWIGTYPE_p_Mezzanine__XML__Node);
5789  }
5790 
5791  result = (arg1)->InsertCopyBefore((Mezzanine::XML::Node const &)*arg2,(Mezzanine::XML::Node const &)*arg3);
5792  {
5793  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
5794  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
5795  }
5796  return SWIG_arg;
5797 
5798  if(0) SWIG_fail;
5799 
5800 fail:
5801  lua_error(L);
5802  return SWIG_arg;
5803 }
5804 
5805 
5806 static int _wrap_Node_InsertCopyBefore(lua_State* L) {
5807  int argc;
5808  int argv[4]={
5809  1,2,3,4
5810  };
5811 
5812  argc = lua_gettop(L);
5813  if (argc == 3) {
5814  int _v;
5815  {
5816  void *ptr;
5817  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
5818  _v = 0;
5819  } else {
5820  _v = 1;
5821  }
5822  }
5823  if (_v) {
5824  {
5825  void *ptr;
5826  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Attribute, 0)) {
5827  _v = 0;
5828  } else {
5829  _v = 1;
5830  }
5831  }
5832  if (_v) {
5833  {
5834  void *ptr;
5835  if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Attribute, 0)) {
5836  _v = 0;
5837  } else {
5838  _v = 1;
5839  }
5840  }
5841  if (_v) {
5842  return _wrap_Node_InsertCopyBefore__SWIG_0(L);
5843  }
5844  }
5845  }
5846  }
5847  if (argc == 3) {
5848  int _v;
5849  {
5850  void *ptr;
5851  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
5852  _v = 0;
5853  } else {
5854  _v = 1;
5855  }
5856  }
5857  if (_v) {
5858  {
5859  void *ptr;
5860  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
5861  _v = 0;
5862  } else {
5863  _v = 1;
5864  }
5865  }
5866  if (_v) {
5867  {
5868  void *ptr;
5869  if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
5870  _v = 0;
5871  } else {
5872  _v = 1;
5873  }
5874  }
5875  if (_v) {
5876  return _wrap_Node_InsertCopyBefore__SWIG_1(L);
5877  }
5878  }
5879  }
5880  }
5881 
5882  lua_pushstring(L,"Wrong arguments for overloaded function 'Node_InsertCopyBefore'\n"
5883  " Possible C/C++ prototypes are:\n"
5884  " Mezzanine::XML::Node::InsertCopyBefore(Mezzanine::XML::Attribute const &,Mezzanine::XML::Attribute const &)\n"
5885  " Mezzanine::XML::Node::InsertCopyBefore(Mezzanine::XML::Node const &,Mezzanine::XML::Node const &)\n");
5886  lua_error(L);return 0;
5887 }
5888 
5889 
5890 static int _wrap_Node_RemoveAttribute__SWIG_0(lua_State* L) {
5891  int SWIG_arg = 0;
5893  Mezzanine::XML::Attribute *arg2 = 0 ;
5894  bool result;
5895 
5896  SWIG_check_num_args("Mezzanine::XML::Node::RemoveAttribute",2,2)
5897  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::RemoveAttribute",1,"Mezzanine::XML::Node *");
5898  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::RemoveAttribute",2,"Mezzanine::XML::Attribute const &");
5899 
5900  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
5901  SWIG_fail_ptr("Node_RemoveAttribute",1,SWIGTYPE_p_Mezzanine__XML__Node);
5902  }
5903 
5904 
5905  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
5906  SWIG_fail_ptr("Node_RemoveAttribute",2,SWIGTYPE_p_Mezzanine__XML__Attribute);
5907  }
5908 
5909  result = (bool)(arg1)->RemoveAttribute((Mezzanine::XML::Attribute const &)*arg2);
5910  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
5911  return SWIG_arg;
5912 
5913  if(0) SWIG_fail;
5914 
5915 fail:
5916  lua_error(L);
5917  return SWIG_arg;
5918 }
5919 
5920 
5921 static int _wrap_Node_RemoveAttribute__SWIG_1(lua_State* L) {
5922  int SWIG_arg = 0;
5924  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
5925  bool result;
5926 
5927  SWIG_check_num_args("Mezzanine::XML::Node::RemoveAttribute",2,2)
5928  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::RemoveAttribute",1,"Mezzanine::XML::Node *");
5929  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::RemoveAttribute",2,"Mezzanine::Char8 const *");
5930 
5931  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
5932  SWIG_fail_ptr("Node_RemoveAttribute",1,SWIGTYPE_p_Mezzanine__XML__Node);
5933  }
5934 
5935  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
5936  result = (bool)(arg1)->RemoveAttribute((Mezzanine::Char8 const *)arg2);
5937  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
5938  return SWIG_arg;
5939 
5940  if(0) SWIG_fail;
5941 
5942 fail:
5943  lua_error(L);
5944  return SWIG_arg;
5945 }
5946 
5947 
5948 static int _wrap_Node_RemoveAttribute(lua_State* L) {
5949  int argc;
5950  int argv[3]={
5951  1,2,3
5952  };
5953 
5954  argc = lua_gettop(L);
5955  if (argc == 2) {
5956  int _v;
5957  {
5958  void *ptr;
5959  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
5960  _v = 0;
5961  } else {
5962  _v = 1;
5963  }
5964  }
5965  if (_v) {
5966  {
5967  void *ptr;
5968  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Attribute, 0)) {
5969  _v = 0;
5970  } else {
5971  _v = 1;
5972  }
5973  }
5974  if (_v) {
5975  return _wrap_Node_RemoveAttribute__SWIG_0(L);
5976  }
5977  }
5978  }
5979  if (argc == 2) {
5980  int _v;
5981  {
5982  void *ptr;
5983  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
5984  _v = 0;
5985  } else {
5986  _v = 1;
5987  }
5988  }
5989  if (_v) {
5990  {
5991  _v = SWIG_lua_isnilstring(L,argv[1]);
5992  }
5993  if (_v) {
5994  return _wrap_Node_RemoveAttribute__SWIG_1(L);
5995  }
5996  }
5997  }
5998 
5999  lua_pushstring(L,"Wrong arguments for overloaded function 'Node_RemoveAttribute'\n"
6000  " Possible C/C++ prototypes are:\n"
6001  " Mezzanine::XML::Node::RemoveAttribute(Mezzanine::XML::Attribute const &)\n"
6002  " Mezzanine::XML::Node::RemoveAttribute(Mezzanine::Char8 const *)\n");
6003  lua_error(L);return 0;
6004 }
6005 
6006 
6007 static int _wrap_Node_RemoveChild__SWIG_0(lua_State* L) {
6008  int SWIG_arg = 0;
6010  Mezzanine::XML::Node *arg2 = 0 ;
6011  bool result;
6012 
6013  SWIG_check_num_args("Mezzanine::XML::Node::RemoveChild",2,2)
6014  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::RemoveChild",1,"Mezzanine::XML::Node *");
6015  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::RemoveChild",2,"Mezzanine::XML::Node const &");
6016 
6017  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
6018  SWIG_fail_ptr("Node_RemoveChild",1,SWIGTYPE_p_Mezzanine__XML__Node);
6019  }
6020 
6021 
6022  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Node,0))){
6023  SWIG_fail_ptr("Node_RemoveChild",2,SWIGTYPE_p_Mezzanine__XML__Node);
6024  }
6025 
6026  result = (bool)(arg1)->RemoveChild((Mezzanine::XML::Node const &)*arg2);
6027  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
6028  return SWIG_arg;
6029 
6030  if(0) SWIG_fail;
6031 
6032 fail:
6033  lua_error(L);
6034  return SWIG_arg;
6035 }
6036 
6037 
6038 static int _wrap_Node_RemoveChild__SWIG_1(lua_State* L) {
6039  int SWIG_arg = 0;
6041  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
6042  bool result;
6043 
6044  SWIG_check_num_args("Mezzanine::XML::Node::RemoveChild",2,2)
6045  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::RemoveChild",1,"Mezzanine::XML::Node *");
6046  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::RemoveChild",2,"Mezzanine::Char8 const *");
6047 
6048  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
6049  SWIG_fail_ptr("Node_RemoveChild",1,SWIGTYPE_p_Mezzanine__XML__Node);
6050  }
6051 
6052  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
6053  result = (bool)(arg1)->RemoveChild((Mezzanine::Char8 const *)arg2);
6054  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
6055  return SWIG_arg;
6056 
6057  if(0) SWIG_fail;
6058 
6059 fail:
6060  lua_error(L);
6061  return SWIG_arg;
6062 }
6063 
6064 
6065 static int _wrap_Node_RemoveChild(lua_State* L) {
6066  int argc;
6067  int argv[3]={
6068  1,2,3
6069  };
6070 
6071  argc = lua_gettop(L);
6072  if (argc == 2) {
6073  int _v;
6074  {
6075  void *ptr;
6076  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
6077  _v = 0;
6078  } else {
6079  _v = 1;
6080  }
6081  }
6082  if (_v) {
6083  {
6084  void *ptr;
6085  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
6086  _v = 0;
6087  } else {
6088  _v = 1;
6089  }
6090  }
6091  if (_v) {
6092  return _wrap_Node_RemoveChild__SWIG_0(L);
6093  }
6094  }
6095  }
6096  if (argc == 2) {
6097  int _v;
6098  {
6099  void *ptr;
6100  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
6101  _v = 0;
6102  } else {
6103  _v = 1;
6104  }
6105  }
6106  if (_v) {
6107  {
6108  _v = SWIG_lua_isnilstring(L,argv[1]);
6109  }
6110  if (_v) {
6111  return _wrap_Node_RemoveChild__SWIG_1(L);
6112  }
6113  }
6114  }
6115 
6116  lua_pushstring(L,"Wrong arguments for overloaded function 'Node_RemoveChild'\n"
6117  " Possible C/C++ prototypes are:\n"
6118  " Mezzanine::XML::Node::RemoveChild(Mezzanine::XML::Node const &)\n"
6119  " Mezzanine::XML::Node::RemoveChild(Mezzanine::Char8 const *)\n");
6120  lua_error(L);return 0;
6121 }
6122 
6123 
6124 static int _wrap_Node_FindChildbyAttribute__SWIG_0(lua_State* L) {
6125  int SWIG_arg = 0;
6127  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
6128  Mezzanine::Char8 *arg3 = (Mezzanine::Char8 *) 0 ;
6129  Mezzanine::Char8 *arg4 = (Mezzanine::Char8 *) 0 ;
6130  Mezzanine::XML::Node result;
6131 
6132  SWIG_check_num_args("Mezzanine::XML::Node::FindChildbyAttribute",4,4)
6133  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::FindChildbyAttribute",1,"Mezzanine::XML::Node const *");
6134  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::FindChildbyAttribute",2,"Mezzanine::Char8 const *");
6135  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::FindChildbyAttribute",3,"Mezzanine::Char8 const *");
6136  if(!SWIG_lua_isnilstring(L,4)) SWIG_fail_arg("Mezzanine::XML::Node::FindChildbyAttribute",4,"Mezzanine::Char8 const *");
6137 
6138  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
6139  SWIG_fail_ptr("Node_FindChildbyAttribute",1,SWIGTYPE_p_Mezzanine__XML__Node);
6140  }
6141 
6142  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
6143  arg3 = (Mezzanine::Char8 *)lua_tostring(L, 3);
6144  arg4 = (Mezzanine::Char8 *)lua_tostring(L, 4);
6145  result = ((Mezzanine::XML::Node const *)arg1)->FindChildbyAttribute((Mezzanine::Char8 const *)arg2,(Mezzanine::Char8 const *)arg3,(Mezzanine::Char8 const *)arg4);
6146  {
6147  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
6148  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
6149  }
6150  return SWIG_arg;
6151 
6152  if(0) SWIG_fail;
6153 
6154 fail:
6155  lua_error(L);
6156  return SWIG_arg;
6157 }
6158 
6159 
6160 static int _wrap_Node_FindChildbyAttribute__SWIG_1(lua_State* L) {
6161  int SWIG_arg = 0;
6163  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
6164  Mezzanine::Char8 *arg3 = (Mezzanine::Char8 *) 0 ;
6165  Mezzanine::XML::Node result;
6166 
6167  SWIG_check_num_args("Mezzanine::XML::Node::FindChildbyAttribute",3,3)
6168  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::FindChildbyAttribute",1,"Mezzanine::XML::Node const *");
6169  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::FindChildbyAttribute",2,"Mezzanine::Char8 const *");
6170  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::FindChildbyAttribute",3,"Mezzanine::Char8 const *");
6171 
6172  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
6173  SWIG_fail_ptr("Node_FindChildbyAttribute",1,SWIGTYPE_p_Mezzanine__XML__Node);
6174  }
6175 
6176  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
6177  arg3 = (Mezzanine::Char8 *)lua_tostring(L, 3);
6178  result = ((Mezzanine::XML::Node const *)arg1)->FindChildbyAttribute((Mezzanine::Char8 const *)arg2,(Mezzanine::Char8 const *)arg3);
6179  {
6180  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
6181  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
6182  }
6183  return SWIG_arg;
6184 
6185  if(0) SWIG_fail;
6186 
6187 fail:
6188  lua_error(L);
6189  return SWIG_arg;
6190 }
6191 
6192 
6193 static int _wrap_Node_FindChildbyAttribute(lua_State* L) {
6194  int argc;
6195  int argv[5]={
6196  1,2,3,4,5
6197  };
6198 
6199  argc = lua_gettop(L);
6200  if (argc == 3) {
6201  int _v;
6202  {
6203  void *ptr;
6204  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
6205  _v = 0;
6206  } else {
6207  _v = 1;
6208  }
6209  }
6210  if (_v) {
6211  {
6212  _v = SWIG_lua_isnilstring(L,argv[1]);
6213  }
6214  if (_v) {
6215  {
6216  _v = SWIG_lua_isnilstring(L,argv[2]);
6217  }
6218  if (_v) {
6219  return _wrap_Node_FindChildbyAttribute__SWIG_1(L);
6220  }
6221  }
6222  }
6223  }
6224  if (argc == 4) {
6225  int _v;
6226  {
6227  void *ptr;
6228  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
6229  _v = 0;
6230  } else {
6231  _v = 1;
6232  }
6233  }
6234  if (_v) {
6235  {
6236  _v = SWIG_lua_isnilstring(L,argv[1]);
6237  }
6238  if (_v) {
6239  {
6240  _v = SWIG_lua_isnilstring(L,argv[2]);
6241  }
6242  if (_v) {
6243  {
6244  _v = SWIG_lua_isnilstring(L,argv[3]);
6245  }
6246  if (_v) {
6247  return _wrap_Node_FindChildbyAttribute__SWIG_0(L);
6248  }
6249  }
6250  }
6251  }
6252  }
6253 
6254  lua_pushstring(L,"Wrong arguments for overloaded function 'Node_FindChildbyAttribute'\n"
6255  " Possible C/C++ prototypes are:\n"
6256  " Mezzanine::XML::Node::FindChildbyAttribute(Mezzanine::Char8 const *,Mezzanine::Char8 const *,Mezzanine::Char8 const *) const\n"
6257  " Mezzanine::XML::Node::FindChildbyAttribute(Mezzanine::Char8 const *,Mezzanine::Char8 const *) const\n");
6258  lua_error(L);return 0;
6259 }
6260 
6261 
6262 static int _wrap_Node_Path__SWIG_0(lua_State* L) {
6263  int SWIG_arg = 0;
6265  Mezzanine::Char8 arg2 ;
6266  Mezzanine::String result;
6267 
6268  SWIG_check_num_args("Mezzanine::XML::Node::Path",2,2)
6269  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Path",1,"Mezzanine::XML::Node const *");
6270  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::Path",2,"Mezzanine::Char8");
6271 
6272  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
6273  SWIG_fail_ptr("Node_Path",1,SWIGTYPE_p_Mezzanine__XML__Node);
6274  }
6275 
6276  arg2 = (lua_tostring(L, 2))[0];
6277  result = ((Mezzanine::XML::Node const *)arg1)->Path(arg2);
6278  lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
6279  return SWIG_arg;
6280 
6281  if(0) SWIG_fail;
6282 
6283 fail:
6284  lua_error(L);
6285  return SWIG_arg;
6286 }
6287 
6288 
6289 static int _wrap_Node_Path__SWIG_1(lua_State* L) {
6290  int SWIG_arg = 0;
6292  Mezzanine::String result;
6293 
6294  SWIG_check_num_args("Mezzanine::XML::Node::Path",1,1)
6295  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Path",1,"Mezzanine::XML::Node const *");
6296 
6297  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
6298  SWIG_fail_ptr("Node_Path",1,SWIGTYPE_p_Mezzanine__XML__Node);
6299  }
6300 
6301  result = ((Mezzanine::XML::Node const *)arg1)->Path();
6302  lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
6303  return SWIG_arg;
6304 
6305  if(0) SWIG_fail;
6306 
6307 fail:
6308  lua_error(L);
6309  return SWIG_arg;
6310 }
6311 
6312 
6313 static int _wrap_Node_Path(lua_State* L) {
6314  int argc;
6315  int argv[3]={
6316  1,2,3
6317  };
6318 
6319  argc = lua_gettop(L);
6320  if (argc == 1) {
6321  int _v;
6322  {
6323  void *ptr;
6324  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
6325  _v = 0;
6326  } else {
6327  _v = 1;
6328  }
6329  }
6330  if (_v) {
6331  return _wrap_Node_Path__SWIG_1(L);
6332  }
6333  }
6334  if (argc == 2) {
6335  int _v;
6336  {
6337  void *ptr;
6338  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
6339  _v = 0;
6340  } else {
6341  _v = 1;
6342  }
6343  }
6344  if (_v) {
6345  {
6346  _v = SWIG_lua_isnilstring(L,argv[1]) && (lua_rawlen(L,argv[1])==1);
6347  }
6348  if (_v) {
6349  return _wrap_Node_Path__SWIG_0(L);
6350  }
6351  }
6352  }
6353 
6354  lua_pushstring(L,"Wrong arguments for overloaded function 'Node_Path'\n"
6355  " Possible C/C++ prototypes are:\n"
6356  " Mezzanine::XML::Node::Path(Mezzanine::Char8) const\n"
6357  " Mezzanine::XML::Node::Path() const\n");
6358  lua_error(L);return 0;
6359 }
6360 
6361 
6362 static int _wrap_Node_FirstElementByPath__SWIG_0(lua_State* L) {
6363  int SWIG_arg = 0;
6365  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
6366  Mezzanine::Char8 arg3 ;
6367  Mezzanine::XML::Node result;
6368 
6369  SWIG_check_num_args("Mezzanine::XML::Node::FirstElementByPath",3,3)
6370  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::FirstElementByPath",1,"Mezzanine::XML::Node const *");
6371  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::FirstElementByPath",2,"Mezzanine::Char8 const *");
6372  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::FirstElementByPath",3,"Mezzanine::Char8");
6373 
6374  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
6375  SWIG_fail_ptr("Node_FirstElementByPath",1,SWIGTYPE_p_Mezzanine__XML__Node);
6376  }
6377 
6378  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
6379  arg3 = (lua_tostring(L, 3))[0];
6380  result = ((Mezzanine::XML::Node const *)arg1)->FirstElementByPath((Mezzanine::Char8 const *)arg2,arg3);
6381  {
6382  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
6383  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
6384  }
6385  return SWIG_arg;
6386 
6387  if(0) SWIG_fail;
6388 
6389 fail:
6390  lua_error(L);
6391  return SWIG_arg;
6392 }
6393 
6394 
6395 static int _wrap_Node_FirstElementByPath__SWIG_1(lua_State* L) {
6396  int SWIG_arg = 0;
6398  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
6399  Mezzanine::XML::Node result;
6400 
6401  SWIG_check_num_args("Mezzanine::XML::Node::FirstElementByPath",2,2)
6402  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::FirstElementByPath",1,"Mezzanine::XML::Node const *");
6403  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::FirstElementByPath",2,"Mezzanine::Char8 const *");
6404 
6405  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
6406  SWIG_fail_ptr("Node_FirstElementByPath",1,SWIGTYPE_p_Mezzanine__XML__Node);
6407  }
6408 
6409  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
6410  result = ((Mezzanine::XML::Node const *)arg1)->FirstElementByPath((Mezzanine::Char8 const *)arg2);
6411  {
6412  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
6413  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
6414  }
6415  return SWIG_arg;
6416 
6417  if(0) SWIG_fail;
6418 
6419 fail:
6420  lua_error(L);
6421  return SWIG_arg;
6422 }
6423 
6424 
6425 static int _wrap_Node_FirstElementByPath(lua_State* L) {
6426  int argc;
6427  int argv[4]={
6428  1,2,3,4
6429  };
6430 
6431  argc = lua_gettop(L);
6432  if (argc == 2) {
6433  int _v;
6434  {
6435  void *ptr;
6436  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
6437  _v = 0;
6438  } else {
6439  _v = 1;
6440  }
6441  }
6442  if (_v) {
6443  {
6444  _v = SWIG_lua_isnilstring(L,argv[1]);
6445  }
6446  if (_v) {
6447  return _wrap_Node_FirstElementByPath__SWIG_1(L);
6448  }
6449  }
6450  }
6451  if (argc == 3) {
6452  int _v;
6453  {
6454  void *ptr;
6455  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
6456  _v = 0;
6457  } else {
6458  _v = 1;
6459  }
6460  }
6461  if (_v) {
6462  {
6463  _v = SWIG_lua_isnilstring(L,argv[1]);
6464  }
6465  if (_v) {
6466  {
6467  _v = SWIG_lua_isnilstring(L,argv[2]) && (lua_rawlen(L,argv[2])==1);
6468  }
6469  if (_v) {
6470  return _wrap_Node_FirstElementByPath__SWIG_0(L);
6471  }
6472  }
6473  }
6474  }
6475 
6476  lua_pushstring(L,"Wrong arguments for overloaded function 'Node_FirstElementByPath'\n"
6477  " Possible C/C++ prototypes are:\n"
6478  " Mezzanine::XML::Node::FirstElementByPath(Mezzanine::Char8 const *,Mezzanine::Char8) const\n"
6479  " Mezzanine::XML::Node::FirstElementByPath(Mezzanine::Char8 const *) const\n");
6480  lua_error(L);return 0;
6481 }
6482 
6483 
6484 static int _wrap_Node_Traverse(lua_State* L) {
6485  int SWIG_arg = 0;
6487  Mezzanine::XML::TreeWalker *arg2 = 0 ;
6488  bool result;
6489 
6490  SWIG_check_num_args("Mezzanine::XML::Node::Traverse",2,2)
6491  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Traverse",1,"Mezzanine::XML::Node *");
6492  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::Traverse",2,"Mezzanine::XML::TreeWalker &");
6493 
6494  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
6495  SWIG_fail_ptr("Node_Traverse",1,SWIGTYPE_p_Mezzanine__XML__Node);
6496  }
6497 
6498 
6499  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__TreeWalker,0))){
6500  SWIG_fail_ptr("Node_Traverse",2,SWIGTYPE_p_Mezzanine__XML__TreeWalker);
6501  }
6502 
6503  result = (bool)(arg1)->Traverse(*arg2);
6504  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
6505  return SWIG_arg;
6506 
6507  if(0) SWIG_fail;
6508 
6509 fail:
6510  lua_error(L);
6511  return SWIG_arg;
6512 }
6513 
6514 
6515 static int _wrap_Node_FindSingleNode__SWIG_0(lua_State* L) {
6516  int SWIG_arg = 0;
6518  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
6521 
6522  SWIG_check_num_args("Mezzanine::XML::Node::FindSingleNode",3,3)
6523  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::FindSingleNode",1,"Mezzanine::XML::Node const *");
6524  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::FindSingleNode",2,"Mezzanine::Char8 const *");
6525  if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::FindSingleNode",3,"Mezzanine::XML::XPathVariableSet *");
6526 
6527  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
6528  SWIG_fail_ptr("Node_FindSingleNode",1,SWIGTYPE_p_Mezzanine__XML__Node);
6529  }
6530 
6531  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
6532 
6533  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__XML__XPathVariableSet,0))){
6534  SWIG_fail_ptr("Node_FindSingleNode",3,SWIGTYPE_p_Mezzanine__XML__XPathVariableSet);
6535  }
6536 
6537  result = ((Mezzanine::XML::Node const *)arg1)->FindSingleNode((Mezzanine::Char8 const *)arg2,arg3);
6538  {
6540  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__XPathNode,1); SWIG_arg++;
6541  }
6542  return SWIG_arg;
6543 
6544  if(0) SWIG_fail;
6545 
6546 fail:
6547  lua_error(L);
6548  return SWIG_arg;
6549 }
6550 
6551 
6552 static int _wrap_Node_FindSingleNode__SWIG_1(lua_State* L) {
6553  int SWIG_arg = 0;
6555  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
6557 
6558  SWIG_check_num_args("Mezzanine::XML::Node::FindSingleNode",2,2)
6559  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::FindSingleNode",1,"Mezzanine::XML::Node const *");
6560  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::FindSingleNode",2,"Mezzanine::Char8 const *");
6561 
6562  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
6563  SWIG_fail_ptr("Node_FindSingleNode",1,SWIGTYPE_p_Mezzanine__XML__Node);
6564  }
6565 
6566  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
6567  result = ((Mezzanine::XML::Node const *)arg1)->FindSingleNode((Mezzanine::Char8 const *)arg2);
6568  {
6570  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__XPathNode,1); SWIG_arg++;
6571  }
6572  return SWIG_arg;
6573 
6574  if(0) SWIG_fail;
6575 
6576 fail:
6577  lua_error(L);
6578  return SWIG_arg;
6579 }
6580 
6581 
6582 static int _wrap_Node_FindSingleNode__SWIG_2(lua_State* L) {
6583  int SWIG_arg = 0;
6585  Mezzanine::XML::XPathQuery *arg2 = 0 ;
6587 
6588  SWIG_check_num_args("Mezzanine::XML::Node::FindSingleNode",2,2)
6589  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::FindSingleNode",1,"Mezzanine::XML::Node const *");
6590  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::FindSingleNode",2,"Mezzanine::XML::XPathQuery const &");
6591 
6592  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
6593  SWIG_fail_ptr("Node_FindSingleNode",1,SWIGTYPE_p_Mezzanine__XML__Node);
6594  }
6595 
6596 
6597  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__XPathQuery,0))){
6598  SWIG_fail_ptr("Node_FindSingleNode",2,SWIGTYPE_p_Mezzanine__XML__XPathQuery);
6599  }
6600 
6601  result = ((Mezzanine::XML::Node const *)arg1)->FindSingleNode((Mezzanine::XML::XPathQuery const &)*arg2);
6602  {
6604  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__XPathNode,1); SWIG_arg++;
6605  }
6606  return SWIG_arg;
6607 
6608  if(0) SWIG_fail;
6609 
6610 fail:
6611  lua_error(L);
6612  return SWIG_arg;
6613 }
6614 
6615 
6616 static int _wrap_Node_FindSingleNode(lua_State* L) {
6617  int argc;
6618  int argv[4]={
6619  1,2,3,4
6620  };
6621 
6622  argc = lua_gettop(L);
6623  if (argc == 2) {
6624  int _v;
6625  {
6626  void *ptr;
6627  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
6628  _v = 0;
6629  } else {
6630  _v = 1;
6631  }
6632  }
6633  if (_v) {
6634  {
6635  void *ptr;
6636  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__XPathQuery, 0)) {
6637  _v = 0;
6638  } else {
6639  _v = 1;
6640  }
6641  }
6642  if (_v) {
6643  return _wrap_Node_FindSingleNode__SWIG_2(L);
6644  }
6645  }
6646  }
6647  if (argc == 2) {
6648  int _v;
6649  {
6650  void *ptr;
6651  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
6652  _v = 0;
6653  } else {
6654  _v = 1;
6655  }
6656  }
6657  if (_v) {
6658  {
6659  _v = SWIG_lua_isnilstring(L,argv[1]);
6660  }
6661  if (_v) {
6662  return _wrap_Node_FindSingleNode__SWIG_1(L);
6663  }
6664  }
6665  }
6666  if (argc == 3) {
6667  int _v;
6668  {
6669  void *ptr;
6670  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
6671  _v = 0;
6672  } else {
6673  _v = 1;
6674  }
6675  }
6676  if (_v) {
6677  {
6678  _v = SWIG_lua_isnilstring(L,argv[1]);
6679  }
6680  if (_v) {
6681  {
6682  void *ptr;
6683  if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__XPathVariableSet, 0)) {
6684  _v = 0;
6685  } else {
6686  _v = 1;
6687  }
6688  }
6689  if (_v) {
6690  return _wrap_Node_FindSingleNode__SWIG_0(L);
6691  }
6692  }
6693  }
6694  }
6695 
6696  lua_pushstring(L,"Wrong arguments for overloaded function 'Node_FindSingleNode'\n"
6697  " Possible C/C++ prototypes are:\n"
6698  " Mezzanine::XML::Node::FindSingleNode(Mezzanine::Char8 const *,Mezzanine::XML::XPathVariableSet *) const\n"
6699  " Mezzanine::XML::Node::FindSingleNode(Mezzanine::Char8 const *) const\n"
6700  " Mezzanine::XML::Node::FindSingleNode(Mezzanine::XML::XPathQuery const &) const\n");
6701  lua_error(L);return 0;
6702 }
6703 
6704 
6705 static int _wrap_Node_FindNodes__SWIG_0(lua_State* L) {
6706  int SWIG_arg = 0;
6708  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
6711 
6712  SWIG_check_num_args("Mezzanine::XML::Node::FindNodes",3,3)
6713  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::FindNodes",1,"Mezzanine::XML::Node const *");
6714  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::FindNodes",2,"Mezzanine::Char8 const *");
6715  if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::FindNodes",3,"Mezzanine::XML::XPathVariableSet *");
6716 
6717  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
6718  SWIG_fail_ptr("Node_FindNodes",1,SWIGTYPE_p_Mezzanine__XML__Node);
6719  }
6720 
6721  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
6722 
6723  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__XML__XPathVariableSet,0))){
6724  SWIG_fail_ptr("Node_FindNodes",3,SWIGTYPE_p_Mezzanine__XML__XPathVariableSet);
6725  }
6726 
6727  result = ((Mezzanine::XML::Node const *)arg1)->FindNodes((Mezzanine::Char8 const *)arg2,arg3);
6728  {
6730  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__XPathNodeSet,1); SWIG_arg++;
6731  }
6732  return SWIG_arg;
6733 
6734  if(0) SWIG_fail;
6735 
6736 fail:
6737  lua_error(L);
6738  return SWIG_arg;
6739 }
6740 
6741 
6742 static int _wrap_Node_FindNodes__SWIG_1(lua_State* L) {
6743  int SWIG_arg = 0;
6745  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
6747 
6748  SWIG_check_num_args("Mezzanine::XML::Node::FindNodes",2,2)
6749  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::FindNodes",1,"Mezzanine::XML::Node const *");
6750  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::FindNodes",2,"Mezzanine::Char8 const *");
6751 
6752  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
6753  SWIG_fail_ptr("Node_FindNodes",1,SWIGTYPE_p_Mezzanine__XML__Node);
6754  }
6755 
6756  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
6757  result = ((Mezzanine::XML::Node const *)arg1)->FindNodes((Mezzanine::Char8 const *)arg2);
6758  {
6760  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__XPathNodeSet,1); SWIG_arg++;
6761  }
6762  return SWIG_arg;
6763 
6764  if(0) SWIG_fail;
6765 
6766 fail:
6767  lua_error(L);
6768  return SWIG_arg;
6769 }
6770 
6771 
6772 static int _wrap_Node_FindNodes__SWIG_2(lua_State* L) {
6773  int SWIG_arg = 0;
6775  Mezzanine::XML::XPathQuery *arg2 = 0 ;
6777 
6778  SWIG_check_num_args("Mezzanine::XML::Node::FindNodes",2,2)
6779  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::FindNodes",1,"Mezzanine::XML::Node const *");
6780  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::FindNodes",2,"Mezzanine::XML::XPathQuery const &");
6781 
6782  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
6783  SWIG_fail_ptr("Node_FindNodes",1,SWIGTYPE_p_Mezzanine__XML__Node);
6784  }
6785 
6786 
6787  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__XPathQuery,0))){
6788  SWIG_fail_ptr("Node_FindNodes",2,SWIGTYPE_p_Mezzanine__XML__XPathQuery);
6789  }
6790 
6791  result = ((Mezzanine::XML::Node const *)arg1)->FindNodes((Mezzanine::XML::XPathQuery const &)*arg2);
6792  {
6794  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__XPathNodeSet,1); SWIG_arg++;
6795  }
6796  return SWIG_arg;
6797 
6798  if(0) SWIG_fail;
6799 
6800 fail:
6801  lua_error(L);
6802  return SWIG_arg;
6803 }
6804 
6805 
6806 static int _wrap_Node_FindNodes(lua_State* L) {
6807  int argc;
6808  int argv[4]={
6809  1,2,3,4
6810  };
6811 
6812  argc = lua_gettop(L);
6813  if (argc == 2) {
6814  int _v;
6815  {
6816  void *ptr;
6817  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
6818  _v = 0;
6819  } else {
6820  _v = 1;
6821  }
6822  }
6823  if (_v) {
6824  {
6825  void *ptr;
6826  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__XPathQuery, 0)) {
6827  _v = 0;
6828  } else {
6829  _v = 1;
6830  }
6831  }
6832  if (_v) {
6833  return _wrap_Node_FindNodes__SWIG_2(L);
6834  }
6835  }
6836  }
6837  if (argc == 2) {
6838  int _v;
6839  {
6840  void *ptr;
6841  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
6842  _v = 0;
6843  } else {
6844  _v = 1;
6845  }
6846  }
6847  if (_v) {
6848  {
6849  _v = SWIG_lua_isnilstring(L,argv[1]);
6850  }
6851  if (_v) {
6852  return _wrap_Node_FindNodes__SWIG_1(L);
6853  }
6854  }
6855  }
6856  if (argc == 3) {
6857  int _v;
6858  {
6859  void *ptr;
6860  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
6861  _v = 0;
6862  } else {
6863  _v = 1;
6864  }
6865  }
6866  if (_v) {
6867  {
6868  _v = SWIG_lua_isnilstring(L,argv[1]);
6869  }
6870  if (_v) {
6871  {
6872  void *ptr;
6873  if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__XPathVariableSet, 0)) {
6874  _v = 0;
6875  } else {
6876  _v = 1;
6877  }
6878  }
6879  if (_v) {
6880  return _wrap_Node_FindNodes__SWIG_0(L);
6881  }
6882  }
6883  }
6884  }
6885 
6886  lua_pushstring(L,"Wrong arguments for overloaded function 'Node_FindNodes'\n"
6887  " Possible C/C++ prototypes are:\n"
6888  " Mezzanine::XML::Node::FindNodes(Mezzanine::Char8 const *,Mezzanine::XML::XPathVariableSet *) const\n"
6889  " Mezzanine::XML::Node::FindNodes(Mezzanine::Char8 const *) const\n"
6890  " Mezzanine::XML::Node::FindNodes(Mezzanine::XML::XPathQuery const &) const\n");
6891  lua_error(L);return 0;
6892 }
6893 
6894 
6895 static int _wrap_Node_Print__SWIG_0(lua_State* L) {
6896  int SWIG_arg = 0;
6898  Mezzanine::XML::Writer *arg2 = 0 ;
6899  Mezzanine::Char8 *arg3 = (Mezzanine::Char8 *) 0 ;
6900  unsigned int arg4 ;
6902  unsigned int arg6 ;
6903 
6904  SWIG_check_num_args("Mezzanine::XML::Node::Print",6,6)
6905  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Print",1,"Mezzanine::XML::Node const *");
6906  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::Print",2,"Mezzanine::XML::Writer &");
6907  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::Print",3,"Mezzanine::Char8 const *");
6908  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::XML::Node::Print",4,"unsigned int");
6909  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::XML::Node::Print",5,"Mezzanine::XML::Encoding");
6910  if(!lua_isnumber(L,6)) SWIG_fail_arg("Mezzanine::XML::Node::Print",6,"unsigned int");
6911 
6912  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
6913  SWIG_fail_ptr("Node_Print",1,SWIGTYPE_p_Mezzanine__XML__Node);
6914  }
6915 
6916 
6917  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Writer,0))){
6918  SWIG_fail_ptr("Node_Print",2,SWIGTYPE_p_Mezzanine__XML__Writer);
6919  }
6920 
6921  arg3 = (Mezzanine::Char8 *)lua_tostring(L, 3);
6922  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
6923  arg4 = (unsigned int)lua_tonumber(L, 4);
6924  arg5 = (Mezzanine::XML::Encoding)(int)lua_tonumber(L, 5);
6925  SWIG_contract_assert((lua_tonumber(L,6)>=0),"number must not be negative")
6926  arg6 = (unsigned int)lua_tonumber(L, 6);
6927  ((Mezzanine::XML::Node const *)arg1)->Print(*arg2,(Mezzanine::Char8 const *)arg3,arg4,arg5,arg6);
6928 
6929  return SWIG_arg;
6930 
6931  if(0) SWIG_fail;
6932 
6933 fail:
6934  lua_error(L);
6935  return SWIG_arg;
6936 }
6937 
6938 
6939 static int _wrap_Node_Print__SWIG_1(lua_State* L) {
6940  int SWIG_arg = 0;
6942  Mezzanine::XML::Writer *arg2 = 0 ;
6943  Mezzanine::Char8 *arg3 = (Mezzanine::Char8 *) 0 ;
6944  unsigned int arg4 ;
6946 
6947  SWIG_check_num_args("Mezzanine::XML::Node::Print",5,5)
6948  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Print",1,"Mezzanine::XML::Node const *");
6949  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::Print",2,"Mezzanine::XML::Writer &");
6950  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::Print",3,"Mezzanine::Char8 const *");
6951  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::XML::Node::Print",4,"unsigned int");
6952  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::XML::Node::Print",5,"Mezzanine::XML::Encoding");
6953 
6954  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
6955  SWIG_fail_ptr("Node_Print",1,SWIGTYPE_p_Mezzanine__XML__Node);
6956  }
6957 
6958 
6959  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Writer,0))){
6960  SWIG_fail_ptr("Node_Print",2,SWIGTYPE_p_Mezzanine__XML__Writer);
6961  }
6962 
6963  arg3 = (Mezzanine::Char8 *)lua_tostring(L, 3);
6964  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
6965  arg4 = (unsigned int)lua_tonumber(L, 4);
6966  arg5 = (Mezzanine::XML::Encoding)(int)lua_tonumber(L, 5);
6967  ((Mezzanine::XML::Node const *)arg1)->Print(*arg2,(Mezzanine::Char8 const *)arg3,arg4,arg5);
6968 
6969  return SWIG_arg;
6970 
6971  if(0) SWIG_fail;
6972 
6973 fail:
6974  lua_error(L);
6975  return SWIG_arg;
6976 }
6977 
6978 
6979 static int _wrap_Node_Print__SWIG_2(lua_State* L) {
6980  int SWIG_arg = 0;
6982  Mezzanine::XML::Writer *arg2 = 0 ;
6983  Mezzanine::Char8 *arg3 = (Mezzanine::Char8 *) 0 ;
6984  unsigned int arg4 ;
6985 
6986  SWIG_check_num_args("Mezzanine::XML::Node::Print",4,4)
6987  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Print",1,"Mezzanine::XML::Node const *");
6988  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::Print",2,"Mezzanine::XML::Writer &");
6989  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::Print",3,"Mezzanine::Char8 const *");
6990  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::XML::Node::Print",4,"unsigned int");
6991 
6992  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
6993  SWIG_fail_ptr("Node_Print",1,SWIGTYPE_p_Mezzanine__XML__Node);
6994  }
6995 
6996 
6997  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Writer,0))){
6998  SWIG_fail_ptr("Node_Print",2,SWIGTYPE_p_Mezzanine__XML__Writer);
6999  }
7000 
7001  arg3 = (Mezzanine::Char8 *)lua_tostring(L, 3);
7002  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
7003  arg4 = (unsigned int)lua_tonumber(L, 4);
7004  ((Mezzanine::XML::Node const *)arg1)->Print(*arg2,(Mezzanine::Char8 const *)arg3,arg4);
7005 
7006  return SWIG_arg;
7007 
7008  if(0) SWIG_fail;
7009 
7010 fail:
7011  lua_error(L);
7012  return SWIG_arg;
7013 }
7014 
7015 
7016 static int _wrap_Node_Print__SWIG_3(lua_State* L) {
7017  int SWIG_arg = 0;
7019  Mezzanine::XML::Writer *arg2 = 0 ;
7020  Mezzanine::Char8 *arg3 = (Mezzanine::Char8 *) 0 ;
7021 
7022  SWIG_check_num_args("Mezzanine::XML::Node::Print",3,3)
7023  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Print",1,"Mezzanine::XML::Node const *");
7024  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::Print",2,"Mezzanine::XML::Writer &");
7025  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::Print",3,"Mezzanine::Char8 const *");
7026 
7027  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
7028  SWIG_fail_ptr("Node_Print",1,SWIGTYPE_p_Mezzanine__XML__Node);
7029  }
7030 
7031 
7032  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Writer,0))){
7033  SWIG_fail_ptr("Node_Print",2,SWIGTYPE_p_Mezzanine__XML__Writer);
7034  }
7035 
7036  arg3 = (Mezzanine::Char8 *)lua_tostring(L, 3);
7037  ((Mezzanine::XML::Node const *)arg1)->Print(*arg2,(Mezzanine::Char8 const *)arg3);
7038 
7039  return SWIG_arg;
7040 
7041  if(0) SWIG_fail;
7042 
7043 fail:
7044  lua_error(L);
7045  return SWIG_arg;
7046 }
7047 
7048 
7049 static int _wrap_Node_Print__SWIG_4(lua_State* L) {
7050  int SWIG_arg = 0;
7052  Mezzanine::XML::Writer *arg2 = 0 ;
7053 
7054  SWIG_check_num_args("Mezzanine::XML::Node::Print",2,2)
7055  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Print",1,"Mezzanine::XML::Node const *");
7056  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::Print",2,"Mezzanine::XML::Writer &");
7057 
7058  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
7059  SWIG_fail_ptr("Node_Print",1,SWIGTYPE_p_Mezzanine__XML__Node);
7060  }
7061 
7062 
7063  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Writer,0))){
7064  SWIG_fail_ptr("Node_Print",2,SWIGTYPE_p_Mezzanine__XML__Writer);
7065  }
7066 
7067  ((Mezzanine::XML::Node const *)arg1)->Print(*arg2);
7068 
7069  return SWIG_arg;
7070 
7071  if(0) SWIG_fail;
7072 
7073 fail:
7074  lua_error(L);
7075  return SWIG_arg;
7076 }
7077 
7078 
7079 static int _wrap_Node_Print__SWIG_5(lua_State* L) {
7080  int SWIG_arg = 0;
7082  std::basic_ostream< char,std::char_traits< char > > *arg2 = 0 ;
7083  Mezzanine::Char8 *arg3 = (Mezzanine::Char8 *) 0 ;
7084  unsigned int arg4 ;
7086  unsigned int arg6 ;
7087 
7088  SWIG_check_num_args("Mezzanine::XML::Node::Print",6,6)
7089  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Print",1,"Mezzanine::XML::Node const *");
7090  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::Print",2,"std::basic_ostream< char,std::char_traits< char > > &");
7091  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::Print",3,"Mezzanine::Char8 const *");
7092  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::XML::Node::Print",4,"unsigned int");
7093  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::XML::Node::Print",5,"Mezzanine::XML::Encoding");
7094  if(!lua_isnumber(L,6)) SWIG_fail_arg("Mezzanine::XML::Node::Print",6,"unsigned int");
7095 
7096  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
7097  SWIG_fail_ptr("Node_Print",1,SWIGTYPE_p_Mezzanine__XML__Node);
7098  }
7099 
7100 
7101  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,0))){
7102  SWIG_fail_ptr("Node_Print",2,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t);
7103  }
7104 
7105  arg3 = (Mezzanine::Char8 *)lua_tostring(L, 3);
7106  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
7107  arg4 = (unsigned int)lua_tonumber(L, 4);
7108  arg5 = (Mezzanine::XML::Encoding)(int)lua_tonumber(L, 5);
7109  SWIG_contract_assert((lua_tonumber(L,6)>=0),"number must not be negative")
7110  arg6 = (unsigned int)lua_tonumber(L, 6);
7111  ((Mezzanine::XML::Node const *)arg1)->Print(*arg2,(Mezzanine::Char8 const *)arg3,arg4,arg5,arg6);
7112 
7113  return SWIG_arg;
7114 
7115  if(0) SWIG_fail;
7116 
7117 fail:
7118  lua_error(L);
7119  return SWIG_arg;
7120 }
7121 
7122 
7123 static int _wrap_Node_Print__SWIG_6(lua_State* L) {
7124  int SWIG_arg = 0;
7126  std::basic_ostream< char,std::char_traits< char > > *arg2 = 0 ;
7127  Mezzanine::Char8 *arg3 = (Mezzanine::Char8 *) 0 ;
7128  unsigned int arg4 ;
7130 
7131  SWIG_check_num_args("Mezzanine::XML::Node::Print",5,5)
7132  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Print",1,"Mezzanine::XML::Node const *");
7133  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::Print",2,"std::basic_ostream< char,std::char_traits< char > > &");
7134  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::Print",3,"Mezzanine::Char8 const *");
7135  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::XML::Node::Print",4,"unsigned int");
7136  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::XML::Node::Print",5,"Mezzanine::XML::Encoding");
7137 
7138  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
7139  SWIG_fail_ptr("Node_Print",1,SWIGTYPE_p_Mezzanine__XML__Node);
7140  }
7141 
7142 
7143  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,0))){
7144  SWIG_fail_ptr("Node_Print",2,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t);
7145  }
7146 
7147  arg3 = (Mezzanine::Char8 *)lua_tostring(L, 3);
7148  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
7149  arg4 = (unsigned int)lua_tonumber(L, 4);
7150  arg5 = (Mezzanine::XML::Encoding)(int)lua_tonumber(L, 5);
7151  ((Mezzanine::XML::Node const *)arg1)->Print(*arg2,(Mezzanine::Char8 const *)arg3,arg4,arg5);
7152 
7153  return SWIG_arg;
7154 
7155  if(0) SWIG_fail;
7156 
7157 fail:
7158  lua_error(L);
7159  return SWIG_arg;
7160 }
7161 
7162 
7163 static int _wrap_Node_Print__SWIG_7(lua_State* L) {
7164  int SWIG_arg = 0;
7166  std::basic_ostream< char,std::char_traits< char > > *arg2 = 0 ;
7167  Mezzanine::Char8 *arg3 = (Mezzanine::Char8 *) 0 ;
7168  unsigned int arg4 ;
7169 
7170  SWIG_check_num_args("Mezzanine::XML::Node::Print",4,4)
7171  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Print",1,"Mezzanine::XML::Node const *");
7172  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::Print",2,"std::basic_ostream< char,std::char_traits< char > > &");
7173  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::Print",3,"Mezzanine::Char8 const *");
7174  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::XML::Node::Print",4,"unsigned int");
7175 
7176  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
7177  SWIG_fail_ptr("Node_Print",1,SWIGTYPE_p_Mezzanine__XML__Node);
7178  }
7179 
7180 
7181  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,0))){
7182  SWIG_fail_ptr("Node_Print",2,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t);
7183  }
7184 
7185  arg3 = (Mezzanine::Char8 *)lua_tostring(L, 3);
7186  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
7187  arg4 = (unsigned int)lua_tonumber(L, 4);
7188  ((Mezzanine::XML::Node const *)arg1)->Print(*arg2,(Mezzanine::Char8 const *)arg3,arg4);
7189 
7190  return SWIG_arg;
7191 
7192  if(0) SWIG_fail;
7193 
7194 fail:
7195  lua_error(L);
7196  return SWIG_arg;
7197 }
7198 
7199 
7200 static int _wrap_Node_Print__SWIG_8(lua_State* L) {
7201  int SWIG_arg = 0;
7203  std::basic_ostream< char,std::char_traits< char > > *arg2 = 0 ;
7204  Mezzanine::Char8 *arg3 = (Mezzanine::Char8 *) 0 ;
7205 
7206  SWIG_check_num_args("Mezzanine::XML::Node::Print",3,3)
7207  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Print",1,"Mezzanine::XML::Node const *");
7208  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::Print",2,"std::basic_ostream< char,std::char_traits< char > > &");
7209  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::Print",3,"Mezzanine::Char8 const *");
7210 
7211  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
7212  SWIG_fail_ptr("Node_Print",1,SWIGTYPE_p_Mezzanine__XML__Node);
7213  }
7214 
7215 
7216  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,0))){
7217  SWIG_fail_ptr("Node_Print",2,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t);
7218  }
7219 
7220  arg3 = (Mezzanine::Char8 *)lua_tostring(L, 3);
7221  ((Mezzanine::XML::Node const *)arg1)->Print(*arg2,(Mezzanine::Char8 const *)arg3);
7222 
7223  return SWIG_arg;
7224 
7225  if(0) SWIG_fail;
7226 
7227 fail:
7228  lua_error(L);
7229  return SWIG_arg;
7230 }
7231 
7232 
7233 static int _wrap_Node_Print__SWIG_9(lua_State* L) {
7234  int SWIG_arg = 0;
7236  std::basic_ostream< char,std::char_traits< char > > *arg2 = 0 ;
7237 
7238  SWIG_check_num_args("Mezzanine::XML::Node::Print",2,2)
7239  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Print",1,"Mezzanine::XML::Node const *");
7240  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::Print",2,"std::basic_ostream< char,std::char_traits< char > > &");
7241 
7242  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
7243  SWIG_fail_ptr("Node_Print",1,SWIGTYPE_p_Mezzanine__XML__Node);
7244  }
7245 
7246 
7247  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,0))){
7248  SWIG_fail_ptr("Node_Print",2,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t);
7249  }
7250 
7251  ((Mezzanine::XML::Node const *)arg1)->Print(*arg2);
7252 
7253  return SWIG_arg;
7254 
7255  if(0) SWIG_fail;
7256 
7257 fail:
7258  lua_error(L);
7259  return SWIG_arg;
7260 }
7261 
7262 
7263 static int _wrap_Node_Print__SWIG_10(lua_State* L) {
7264  int SWIG_arg = 0;
7266  std::basic_ostream< wchar_t,std::char_traits< wchar_t > > *arg2 = 0 ;
7267  Mezzanine::Char8 *arg3 = (Mezzanine::Char8 *) 0 ;
7268  unsigned int arg4 ;
7269  unsigned int arg5 ;
7270 
7271  SWIG_check_num_args("Mezzanine::XML::Node::Print",5,5)
7272  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Print",1,"Mezzanine::XML::Node const *");
7273  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::Print",2,"std::basic_ostream< wchar_t,std::char_traits< wchar_t > > &");
7274  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::Print",3,"Mezzanine::Char8 const *");
7275  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::XML::Node::Print",4,"unsigned int");
7276  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::XML::Node::Print",5,"unsigned int");
7277 
7278  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
7279  SWIG_fail_ptr("Node_Print",1,SWIGTYPE_p_Mezzanine__XML__Node);
7280  }
7281 
7282 
7283  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__basic_ostreamT_wchar_t_std__char_traitsT_wchar_t_t_t,0))){
7284  SWIG_fail_ptr("Node_Print",2,SWIGTYPE_p_std__basic_ostreamT_wchar_t_std__char_traitsT_wchar_t_t_t);
7285  }
7286 
7287  arg3 = (Mezzanine::Char8 *)lua_tostring(L, 3);
7288  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
7289  arg4 = (unsigned int)lua_tonumber(L, 4);
7290  SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative")
7291  arg5 = (unsigned int)lua_tonumber(L, 5);
7292  ((Mezzanine::XML::Node const *)arg1)->Print(*arg2,(Mezzanine::Char8 const *)arg3,arg4,arg5);
7293 
7294  return SWIG_arg;
7295 
7296  if(0) SWIG_fail;
7297 
7298 fail:
7299  lua_error(L);
7300  return SWIG_arg;
7301 }
7302 
7303 
7304 static int _wrap_Node_Print__SWIG_11(lua_State* L) {
7305  int SWIG_arg = 0;
7307  std::basic_ostream< wchar_t,std::char_traits< wchar_t > > *arg2 = 0 ;
7308  Mezzanine::Char8 *arg3 = (Mezzanine::Char8 *) 0 ;
7309  unsigned int arg4 ;
7310 
7311  SWIG_check_num_args("Mezzanine::XML::Node::Print",4,4)
7312  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Print",1,"Mezzanine::XML::Node const *");
7313  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::Print",2,"std::basic_ostream< wchar_t,std::char_traits< wchar_t > > &");
7314  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::Print",3,"Mezzanine::Char8 const *");
7315  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::XML::Node::Print",4,"unsigned int");
7316 
7317  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
7318  SWIG_fail_ptr("Node_Print",1,SWIGTYPE_p_Mezzanine__XML__Node);
7319  }
7320 
7321 
7322  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__basic_ostreamT_wchar_t_std__char_traitsT_wchar_t_t_t,0))){
7323  SWIG_fail_ptr("Node_Print",2,SWIGTYPE_p_std__basic_ostreamT_wchar_t_std__char_traitsT_wchar_t_t_t);
7324  }
7325 
7326  arg3 = (Mezzanine::Char8 *)lua_tostring(L, 3);
7327  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
7328  arg4 = (unsigned int)lua_tonumber(L, 4);
7329  ((Mezzanine::XML::Node const *)arg1)->Print(*arg2,(Mezzanine::Char8 const *)arg3,arg4);
7330 
7331  return SWIG_arg;
7332 
7333  if(0) SWIG_fail;
7334 
7335 fail:
7336  lua_error(L);
7337  return SWIG_arg;
7338 }
7339 
7340 
7341 static int _wrap_Node_Print__SWIG_12(lua_State* L) {
7342  int SWIG_arg = 0;
7344  std::basic_ostream< wchar_t,std::char_traits< wchar_t > > *arg2 = 0 ;
7345  Mezzanine::Char8 *arg3 = (Mezzanine::Char8 *) 0 ;
7346 
7347  SWIG_check_num_args("Mezzanine::XML::Node::Print",3,3)
7348  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Print",1,"Mezzanine::XML::Node const *");
7349  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::Print",2,"std::basic_ostream< wchar_t,std::char_traits< wchar_t > > &");
7350  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::Print",3,"Mezzanine::Char8 const *");
7351 
7352  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
7353  SWIG_fail_ptr("Node_Print",1,SWIGTYPE_p_Mezzanine__XML__Node);
7354  }
7355 
7356 
7357  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__basic_ostreamT_wchar_t_std__char_traitsT_wchar_t_t_t,0))){
7358  SWIG_fail_ptr("Node_Print",2,SWIGTYPE_p_std__basic_ostreamT_wchar_t_std__char_traitsT_wchar_t_t_t);
7359  }
7360 
7361  arg3 = (Mezzanine::Char8 *)lua_tostring(L, 3);
7362  ((Mezzanine::XML::Node const *)arg1)->Print(*arg2,(Mezzanine::Char8 const *)arg3);
7363 
7364  return SWIG_arg;
7365 
7366  if(0) SWIG_fail;
7367 
7368 fail:
7369  lua_error(L);
7370  return SWIG_arg;
7371 }
7372 
7373 
7374 static int _wrap_Node_Print__SWIG_13(lua_State* L) {
7375  int SWIG_arg = 0;
7377  std::basic_ostream< wchar_t,std::char_traits< wchar_t > > *arg2 = 0 ;
7378 
7379  SWIG_check_num_args("Mezzanine::XML::Node::Print",2,2)
7380  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Print",1,"Mezzanine::XML::Node const *");
7381  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::Print",2,"std::basic_ostream< wchar_t,std::char_traits< wchar_t > > &");
7382 
7383  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
7384  SWIG_fail_ptr("Node_Print",1,SWIGTYPE_p_Mezzanine__XML__Node);
7385  }
7386 
7387 
7388  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__basic_ostreamT_wchar_t_std__char_traitsT_wchar_t_t_t,0))){
7389  SWIG_fail_ptr("Node_Print",2,SWIGTYPE_p_std__basic_ostreamT_wchar_t_std__char_traitsT_wchar_t_t_t);
7390  }
7391 
7392  ((Mezzanine::XML::Node const *)arg1)->Print(*arg2);
7393 
7394  return SWIG_arg;
7395 
7396  if(0) SWIG_fail;
7397 
7398 fail:
7399  lua_error(L);
7400  return SWIG_arg;
7401 }
7402 
7403 
7404 static int _wrap_Node_Print(lua_State* L) {
7405  int argc;
7406  int argv[7]={
7407  1,2,3,4,5,6,7
7408  };
7409 
7410  argc = lua_gettop(L);
7411  if (argc == 2) {
7412  int _v;
7413  {
7414  void *ptr;
7415  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
7416  _v = 0;
7417  } else {
7418  _v = 1;
7419  }
7420  }
7421  if (_v) {
7422  {
7423  void *ptr;
7424  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Writer, 0)) {
7425  _v = 0;
7426  } else {
7427  _v = 1;
7428  }
7429  }
7430  if (_v) {
7431  return _wrap_Node_Print__SWIG_4(L);
7432  }
7433  }
7434  }
7435  if (argc == 2) {
7436  int _v;
7437  {
7438  void *ptr;
7439  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
7440  _v = 0;
7441  } else {
7442  _v = 1;
7443  }
7444  }
7445  if (_v) {
7446  {
7447  void *ptr;
7448  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0)) {
7449  _v = 0;
7450  } else {
7451  _v = 1;
7452  }
7453  }
7454  if (_v) {
7455  return _wrap_Node_Print__SWIG_9(L);
7456  }
7457  }
7458  }
7459  if (argc == 2) {
7460  int _v;
7461  {
7462  void *ptr;
7463  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
7464  _v = 0;
7465  } else {
7466  _v = 1;
7467  }
7468  }
7469  if (_v) {
7470  {
7471  void *ptr;
7472  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__basic_ostreamT_wchar_t_std__char_traitsT_wchar_t_t_t, 0)) {
7473  _v = 0;
7474  } else {
7475  _v = 1;
7476  }
7477  }
7478  if (_v) {
7479  return _wrap_Node_Print__SWIG_13(L);
7480  }
7481  }
7482  }
7483  if (argc == 3) {
7484  int _v;
7485  {
7486  void *ptr;
7487  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
7488  _v = 0;
7489  } else {
7490  _v = 1;
7491  }
7492  }
7493  if (_v) {
7494  {
7495  void *ptr;
7496  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Writer, 0)) {
7497  _v = 0;
7498  } else {
7499  _v = 1;
7500  }
7501  }
7502  if (_v) {
7503  {
7504  _v = SWIG_lua_isnilstring(L,argv[2]);
7505  }
7506  if (_v) {
7507  return _wrap_Node_Print__SWIG_3(L);
7508  }
7509  }
7510  }
7511  }
7512  if (argc == 3) {
7513  int _v;
7514  {
7515  void *ptr;
7516  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
7517  _v = 0;
7518  } else {
7519  _v = 1;
7520  }
7521  }
7522  if (_v) {
7523  {
7524  void *ptr;
7525  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__basic_ostreamT_wchar_t_std__char_traitsT_wchar_t_t_t, 0)) {
7526  _v = 0;
7527  } else {
7528  _v = 1;
7529  }
7530  }
7531  if (_v) {
7532  {
7533  _v = SWIG_lua_isnilstring(L,argv[2]);
7534  }
7535  if (_v) {
7536  return _wrap_Node_Print__SWIG_12(L);
7537  }
7538  }
7539  }
7540  }
7541  if (argc == 3) {
7542  int _v;
7543  {
7544  void *ptr;
7545  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
7546  _v = 0;
7547  } else {
7548  _v = 1;
7549  }
7550  }
7551  if (_v) {
7552  {
7553  void *ptr;
7554  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0)) {
7555  _v = 0;
7556  } else {
7557  _v = 1;
7558  }
7559  }
7560  if (_v) {
7561  {
7562  _v = SWIG_lua_isnilstring(L,argv[2]);
7563  }
7564  if (_v) {
7565  return _wrap_Node_Print__SWIG_8(L);
7566  }
7567  }
7568  }
7569  }
7570  if (argc == 4) {
7571  int _v;
7572  {
7573  void *ptr;
7574  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
7575  _v = 0;
7576  } else {
7577  _v = 1;
7578  }
7579  }
7580  if (_v) {
7581  {
7582  void *ptr;
7583  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__basic_ostreamT_wchar_t_std__char_traitsT_wchar_t_t_t, 0)) {
7584  _v = 0;
7585  } else {
7586  _v = 1;
7587  }
7588  }
7589  if (_v) {
7590  {
7591  _v = SWIG_lua_isnilstring(L,argv[2]);
7592  }
7593  if (_v) {
7594  {
7595  _v = lua_isnumber(L,argv[3]);
7596  }
7597  if (_v) {
7598  return _wrap_Node_Print__SWIG_11(L);
7599  }
7600  }
7601  }
7602  }
7603  }
7604  if (argc == 4) {
7605  int _v;
7606  {
7607  void *ptr;
7608  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
7609  _v = 0;
7610  } else {
7611  _v = 1;
7612  }
7613  }
7614  if (_v) {
7615  {
7616  void *ptr;
7617  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Writer, 0)) {
7618  _v = 0;
7619  } else {
7620  _v = 1;
7621  }
7622  }
7623  if (_v) {
7624  {
7625  _v = SWIG_lua_isnilstring(L,argv[2]);
7626  }
7627  if (_v) {
7628  {
7629  _v = lua_isnumber(L,argv[3]);
7630  }
7631  if (_v) {
7632  return _wrap_Node_Print__SWIG_2(L);
7633  }
7634  }
7635  }
7636  }
7637  }
7638  if (argc == 4) {
7639  int _v;
7640  {
7641  void *ptr;
7642  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
7643  _v = 0;
7644  } else {
7645  _v = 1;
7646  }
7647  }
7648  if (_v) {
7649  {
7650  void *ptr;
7651  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0)) {
7652  _v = 0;
7653  } else {
7654  _v = 1;
7655  }
7656  }
7657  if (_v) {
7658  {
7659  _v = SWIG_lua_isnilstring(L,argv[2]);
7660  }
7661  if (_v) {
7662  {
7663  _v = lua_isnumber(L,argv[3]);
7664  }
7665  if (_v) {
7666  return _wrap_Node_Print__SWIG_7(L);
7667  }
7668  }
7669  }
7670  }
7671  }
7672  if (argc == 5) {
7673  int _v;
7674  {
7675  void *ptr;
7676  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
7677  _v = 0;
7678  } else {
7679  _v = 1;
7680  }
7681  }
7682  if (_v) {
7683  {
7684  void *ptr;
7685  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0)) {
7686  _v = 0;
7687  } else {
7688  _v = 1;
7689  }
7690  }
7691  if (_v) {
7692  {
7693  _v = SWIG_lua_isnilstring(L,argv[2]);
7694  }
7695  if (_v) {
7696  {
7697  _v = lua_isnumber(L,argv[3]);
7698  }
7699  if (_v) {
7700  {
7701  _v = lua_isnumber(L,argv[4]);
7702  }
7703  if (_v) {
7704  return _wrap_Node_Print__SWIG_6(L);
7705  }
7706  }
7707  }
7708  }
7709  }
7710  }
7711  if (argc == 5) {
7712  int _v;
7713  {
7714  void *ptr;
7715  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
7716  _v = 0;
7717  } else {
7718  _v = 1;
7719  }
7720  }
7721  if (_v) {
7722  {
7723  void *ptr;
7724  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Writer, 0)) {
7725  _v = 0;
7726  } else {
7727  _v = 1;
7728  }
7729  }
7730  if (_v) {
7731  {
7732  _v = SWIG_lua_isnilstring(L,argv[2]);
7733  }
7734  if (_v) {
7735  {
7736  _v = lua_isnumber(L,argv[3]);
7737  }
7738  if (_v) {
7739  {
7740  _v = lua_isnumber(L,argv[4]);
7741  }
7742  if (_v) {
7743  return _wrap_Node_Print__SWIG_1(L);
7744  }
7745  }
7746  }
7747  }
7748  }
7749  }
7750  if (argc == 5) {
7751  int _v;
7752  {
7753  void *ptr;
7754  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
7755  _v = 0;
7756  } else {
7757  _v = 1;
7758  }
7759  }
7760  if (_v) {
7761  {
7762  void *ptr;
7763  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__basic_ostreamT_wchar_t_std__char_traitsT_wchar_t_t_t, 0)) {
7764  _v = 0;
7765  } else {
7766  _v = 1;
7767  }
7768  }
7769  if (_v) {
7770  {
7771  _v = SWIG_lua_isnilstring(L,argv[2]);
7772  }
7773  if (_v) {
7774  {
7775  _v = lua_isnumber(L,argv[3]);
7776  }
7777  if (_v) {
7778  {
7779  _v = lua_isnumber(L,argv[4]);
7780  }
7781  if (_v) {
7782  return _wrap_Node_Print__SWIG_10(L);
7783  }
7784  }
7785  }
7786  }
7787  }
7788  }
7789  if (argc == 6) {
7790  int _v;
7791  {
7792  void *ptr;
7793  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
7794  _v = 0;
7795  } else {
7796  _v = 1;
7797  }
7798  }
7799  if (_v) {
7800  {
7801  void *ptr;
7802  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Writer, 0)) {
7803  _v = 0;
7804  } else {
7805  _v = 1;
7806  }
7807  }
7808  if (_v) {
7809  {
7810  _v = SWIG_lua_isnilstring(L,argv[2]);
7811  }
7812  if (_v) {
7813  {
7814  _v = lua_isnumber(L,argv[3]);
7815  }
7816  if (_v) {
7817  {
7818  _v = lua_isnumber(L,argv[4]);
7819  }
7820  if (_v) {
7821  {
7822  _v = lua_isnumber(L,argv[5]);
7823  }
7824  if (_v) {
7825  return _wrap_Node_Print__SWIG_0(L);
7826  }
7827  }
7828  }
7829  }
7830  }
7831  }
7832  }
7833  if (argc == 6) {
7834  int _v;
7835  {
7836  void *ptr;
7837  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
7838  _v = 0;
7839  } else {
7840  _v = 1;
7841  }
7842  }
7843  if (_v) {
7844  {
7845  void *ptr;
7846  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0)) {
7847  _v = 0;
7848  } else {
7849  _v = 1;
7850  }
7851  }
7852  if (_v) {
7853  {
7854  _v = SWIG_lua_isnilstring(L,argv[2]);
7855  }
7856  if (_v) {
7857  {
7858  _v = lua_isnumber(L,argv[3]);
7859  }
7860  if (_v) {
7861  {
7862  _v = lua_isnumber(L,argv[4]);
7863  }
7864  if (_v) {
7865  {
7866  _v = lua_isnumber(L,argv[5]);
7867  }
7868  if (_v) {
7869  return _wrap_Node_Print__SWIG_5(L);
7870  }
7871  }
7872  }
7873  }
7874  }
7875  }
7876  }
7877 
7878  lua_pushstring(L,"Wrong arguments for overloaded function 'Node_Print'\n"
7879  " Possible C/C++ prototypes are:\n"
7880  " Mezzanine::XML::Node::Print(Mezzanine::XML::Writer &,Mezzanine::Char8 const *,unsigned int,Mezzanine::XML::Encoding,unsigned int) const\n"
7881  " Mezzanine::XML::Node::Print(Mezzanine::XML::Writer &,Mezzanine::Char8 const *,unsigned int,Mezzanine::XML::Encoding) const\n"
7882  " Mezzanine::XML::Node::Print(Mezzanine::XML::Writer &,Mezzanine::Char8 const *,unsigned int) const\n"
7883  " Mezzanine::XML::Node::Print(Mezzanine::XML::Writer &,Mezzanine::Char8 const *) const\n"
7884  " Mezzanine::XML::Node::Print(Mezzanine::XML::Writer &) const\n"
7885  " Mezzanine::XML::Node::Print(std::basic_ostream< char,std::char_traits< char > > &,Mezzanine::Char8 const *,unsigned int,Mezzanine::XML::Encoding,unsigned int) const\n"
7886  " Mezzanine::XML::Node::Print(std::basic_ostream< char,std::char_traits< char > > &,Mezzanine::Char8 const *,unsigned int,Mezzanine::XML::Encoding) const\n"
7887  " Mezzanine::XML::Node::Print(std::basic_ostream< char,std::char_traits< char > > &,Mezzanine::Char8 const *,unsigned int) const\n"
7888  " Mezzanine::XML::Node::Print(std::basic_ostream< char,std::char_traits< char > > &,Mezzanine::Char8 const *) const\n"
7889  " Mezzanine::XML::Node::Print(std::basic_ostream< char,std::char_traits< char > > &) const\n"
7890  " Mezzanine::XML::Node::Print(std::basic_ostream< wchar_t,std::char_traits< wchar_t > > &,Mezzanine::Char8 const *,unsigned int,unsigned int) const\n"
7891  " Mezzanine::XML::Node::Print(std::basic_ostream< wchar_t,std::char_traits< wchar_t > > &,Mezzanine::Char8 const *,unsigned int) const\n"
7892  " Mezzanine::XML::Node::Print(std::basic_ostream< wchar_t,std::char_traits< wchar_t > > &,Mezzanine::Char8 const *) const\n"
7893  " Mezzanine::XML::Node::Print(std::basic_ostream< wchar_t,std::char_traits< wchar_t > > &) const\n");
7894  lua_error(L);return 0;
7895 }
7896 
7897 
7898 static int _wrap_Node_begin(lua_State* L) {
7899  int SWIG_arg = 0;
7902 
7903  SWIG_check_num_args("Mezzanine::XML::Node::begin",1,1)
7904  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::begin",1,"Mezzanine::XML::Node const *");
7905 
7906  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
7907  SWIG_fail_ptr("Node_begin",1,SWIGTYPE_p_Mezzanine__XML__Node);
7908  }
7909 
7910  result = ((Mezzanine::XML::Node const *)arg1)->begin();
7911  {
7913  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__NodeIterator,1); SWIG_arg++;
7914  }
7915  return SWIG_arg;
7916 
7917  if(0) SWIG_fail;
7918 
7919 fail:
7920  lua_error(L);
7921  return SWIG_arg;
7922 }
7923 
7924 
7925 static int _wrap_Node_end(lua_State* L) {
7926  int SWIG_arg = 0;
7929 
7930  SWIG_check_num_args("Mezzanine::XML::Node::end",1,1)
7931  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::end",1,"Mezzanine::XML::Node const *");
7932 
7933  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
7934  SWIG_fail_ptr("Node_end",1,SWIGTYPE_p_Mezzanine__XML__Node);
7935  }
7936 
7937  result = ((Mezzanine::XML::Node const *)arg1)->end();
7938  {
7940  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__NodeIterator,1); SWIG_arg++;
7941  }
7942  return SWIG_arg;
7943 
7944  if(0) SWIG_fail;
7945 
7946 fail:
7947  lua_error(L);
7948  return SWIG_arg;
7949 }
7950 
7951 
7952 static int _wrap_Node_attributes_begin(lua_State* L) {
7953  int SWIG_arg = 0;
7956 
7957  SWIG_check_num_args("Mezzanine::XML::Node::attributes_begin",1,1)
7958  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::attributes_begin",1,"Mezzanine::XML::Node const *");
7959 
7960  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
7961  SWIG_fail_ptr("Node_attributes_begin",1,SWIGTYPE_p_Mezzanine__XML__Node);
7962  }
7963 
7964  result = ((Mezzanine::XML::Node const *)arg1)->attributes_begin();
7965  {
7967  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__AttributeIterator,1); SWIG_arg++;
7968  }
7969  return SWIG_arg;
7970 
7971  if(0) SWIG_fail;
7972 
7973 fail:
7974  lua_error(L);
7975  return SWIG_arg;
7976 }
7977 
7978 
7979 static int _wrap_Node_attributes_end(lua_State* L) {
7980  int SWIG_arg = 0;
7983 
7984  SWIG_check_num_args("Mezzanine::XML::Node::attributes_end",1,1)
7985  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::attributes_end",1,"Mezzanine::XML::Node const *");
7986 
7987  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
7988  SWIG_fail_ptr("Node_attributes_end",1,SWIGTYPE_p_Mezzanine__XML__Node);
7989  }
7990 
7991  result = ((Mezzanine::XML::Node const *)arg1)->attributes_end();
7992  {
7994  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__AttributeIterator,1); SWIG_arg++;
7995  }
7996  return SWIG_arg;
7997 
7998  if(0) SWIG_fail;
7999 
8000 fail:
8001  lua_error(L);
8002  return SWIG_arg;
8003 }
8004 
8005 
8006 static int _wrap_Node_GetChildren__SWIG_0(lua_State* L) {
8007  int SWIG_arg = 0;
8009  SwigValueWrapper< Mezzanine::XML::ObjectRange< Mezzanine::XML::NodeIterator > > result;
8010 
8011  SWIG_check_num_args("Mezzanine::XML::Node::GetChildren",1,1)
8012  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::GetChildren",1,"Mezzanine::XML::Node const *");
8013 
8014  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
8015  SWIG_fail_ptr("Node_GetChildren",1,SWIGTYPE_p_Mezzanine__XML__Node);
8016  }
8017 
8018  result = ((Mezzanine::XML::Node const *)arg1)->GetChildren();
8019  {
8021  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__ObjectRangeT_Mezzanine__XML__NodeIterator_t,1); SWIG_arg++;
8022  }
8023  return SWIG_arg;
8024 
8025  if(0) SWIG_fail;
8026 
8027 fail:
8028  lua_error(L);
8029  return SWIG_arg;
8030 }
8031 
8032 
8033 static int _wrap_Node_GetChildren__SWIG_1(lua_State* L) {
8034  int SWIG_arg = 0;
8036  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
8037  SwigValueWrapper< Mezzanine::XML::ObjectRange< Mezzanine::XML::NamedNodeIterator > > result;
8038 
8039  SWIG_check_num_args("Mezzanine::XML::Node::GetChildren",2,2)
8040  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::GetChildren",1,"Mezzanine::XML::Node const *");
8041  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::GetChildren",2,"Mezzanine::Char8 const *");
8042 
8043  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
8044  SWIG_fail_ptr("Node_GetChildren",1,SWIGTYPE_p_Mezzanine__XML__Node);
8045  }
8046 
8047  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
8048  result = ((Mezzanine::XML::Node const *)arg1)->GetChildren((Mezzanine::Char8 const *)arg2);
8049  {
8051  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__ObjectRangeT_Mezzanine__XML__NamedNodeIterator_t,1); SWIG_arg++;
8052  }
8053  return SWIG_arg;
8054 
8055  if(0) SWIG_fail;
8056 
8057 fail:
8058  lua_error(L);
8059  return SWIG_arg;
8060 }
8061 
8062 
8063 static int _wrap_Node_GetChildren(lua_State* L) {
8064  int argc;
8065  int argv[3]={
8066  1,2,3
8067  };
8068 
8069  argc = lua_gettop(L);
8070  if (argc == 1) {
8071  int _v;
8072  {
8073  void *ptr;
8074  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
8075  _v = 0;
8076  } else {
8077  _v = 1;
8078  }
8079  }
8080  if (_v) {
8081  return _wrap_Node_GetChildren__SWIG_0(L);
8082  }
8083  }
8084  if (argc == 2) {
8085  int _v;
8086  {
8087  void *ptr;
8088  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
8089  _v = 0;
8090  } else {
8091  _v = 1;
8092  }
8093  }
8094  if (_v) {
8095  {
8096  _v = SWIG_lua_isnilstring(L,argv[1]);
8097  }
8098  if (_v) {
8099  return _wrap_Node_GetChildren__SWIG_1(L);
8100  }
8101  }
8102  }
8103 
8104  lua_pushstring(L,"Wrong arguments for overloaded function 'Node_GetChildren'\n"
8105  " Possible C/C++ prototypes are:\n"
8106  " Mezzanine::XML::Node::GetChildren() const\n"
8107  " Mezzanine::XML::Node::GetChildren(Mezzanine::Char8 const *) const\n");
8108  lua_error(L);return 0;
8109 }
8110 
8111 
8112 static int _wrap_Node_attributes(lua_State* L) {
8113  int SWIG_arg = 0;
8115  SwigValueWrapper< Mezzanine::XML::ObjectRange< Mezzanine::XML::AttributeIterator > > result;
8116 
8117  SWIG_check_num_args("Mezzanine::XML::Node::attributes",1,1)
8118  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::attributes",1,"Mezzanine::XML::Node const *");
8119 
8120  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
8121  SWIG_fail_ptr("Node_attributes",1,SWIGTYPE_p_Mezzanine__XML__Node);
8122  }
8123 
8124  result = ((Mezzanine::XML::Node const *)arg1)->attributes();
8125  {
8127  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__ObjectRangeT_Mezzanine__XML__AttributeIterator_t,1); SWIG_arg++;
8128  }
8129  return SWIG_arg;
8130 
8131  if(0) SWIG_fail;
8132 
8133 fail:
8134  lua_error(L);
8135  return SWIG_arg;
8136 }
8137 
8138 
8139 static int _wrap_Node_OffSetDebug(lua_State* L) {
8140  int SWIG_arg = 0;
8142  ptrdiff_t result;
8143 
8144  SWIG_check_num_args("Mezzanine::XML::Node::OffSetDebug",1,1)
8145  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::OffSetDebug",1,"Mezzanine::XML::Node const *");
8146 
8147  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
8148  SWIG_fail_ptr("Node_OffSetDebug",1,SWIGTYPE_p_Mezzanine__XML__Node);
8149  }
8150 
8151  result = ((Mezzanine::XML::Node const *)arg1)->OffSetDebug();
8152  {
8153  ptrdiff_t * resultptr = new ptrdiff_t((const ptrdiff_t &) result);
8154  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ptrdiff_t,1); SWIG_arg++;
8155  }
8156  return SWIG_arg;
8157 
8158  if(0) SWIG_fail;
8159 
8160 fail:
8161  lua_error(L);
8162  return SWIG_arg;
8163 }
8164 
8165 
8166 static int _wrap_Node_HashValue(lua_State* L) {
8167  int SWIG_arg = 0;
8169  size_t result;
8170 
8171  SWIG_check_num_args("Mezzanine::XML::Node::HashValue",1,1)
8172  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::HashValue",1,"Mezzanine::XML::Node const *");
8173 
8174  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
8175  SWIG_fail_ptr("Node_HashValue",1,SWIGTYPE_p_Mezzanine__XML__Node);
8176  }
8177 
8178  result = ((Mezzanine::XML::Node const *)arg1)->HashValue();
8179  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
8180  return SWIG_arg;
8181 
8182  if(0) SWIG_fail;
8183 
8184 fail:
8185  lua_error(L);
8186  return SWIG_arg;
8187 }
8188 
8189 
8190 static int _wrap_Node_InternalObject(lua_State* L) {
8191  int SWIG_arg = 0;
8193  Mezzanine::XML::NodeStruct *result = 0 ;
8194 
8195  SWIG_check_num_args("Mezzanine::XML::Node::InternalObject",1,1)
8196  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::InternalObject",1,"Mezzanine::XML::Node const *");
8197 
8198  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
8199  SWIG_fail_ptr("Node_InternalObject",1,SWIGTYPE_p_Mezzanine__XML__Node);
8200  }
8201 
8202  result = (Mezzanine::XML::NodeStruct *)((Mezzanine::XML::Node const *)arg1)->InternalObject();
8203  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__XML__NodeStruct,0); SWIG_arg++;
8204  return SWIG_arg;
8205 
8206  if(0) SWIG_fail;
8207 
8208 fail:
8209  lua_error(L);
8210  return SWIG_arg;
8211 }
8212 
8213 
8214 static void swig_delete_Node(void *obj) {
8216 delete arg1;
8217 }
8218 static swig_lua_method swig_Mezzanine_XML_Node_methods[] = {
8219  {"__lt", _wrap_Node___lt},
8220  {"__le", _wrap_Node___le},
8221  {"Empty", _wrap_Node_Empty},
8222  {"Type", _wrap_Node_Type},
8223  {"Name", _wrap_Node_Name},
8224  {"Value", _wrap_Node_Value},
8225  {"GetFirstAttribute", _wrap_Node_GetFirstAttribute},
8226  {"GetLastAttribute", _wrap_Node_GetLastAttribute},
8227  {"GetFirstChild", _wrap_Node_GetFirstChild},
8228  {"GetLastChild", _wrap_Node_GetLastChild},
8229  {"GetParent", _wrap_Node_GetParent},
8230  {"GetRoot", _wrap_Node_GetRoot},
8231  {"GetText", _wrap_Node_GetText},
8232  {"GetChild", _wrap_Node_GetChild},
8233  {"GetAttribute", _wrap_Node_GetAttribute},
8234  {"GetNextSibling", _wrap_Node_GetNextSibling},
8235  {"GetPreviousSibling", _wrap_Node_GetPreviousSibling},
8236  {"GetChildValue", _wrap_Node_GetChildValue},
8237  {"SetName", _wrap_Node_SetName},
8238  {"SetValue", _wrap_Node_SetValue},
8239  {"AppendAttribute", _wrap_Node_AppendAttribute},
8240  {"PrependAttribute", _wrap_Node_PrependAttribute},
8241  {"InsertAttributeAfter", _wrap_Node_InsertAttributeAfter},
8242  {"InsertAttributeBefore", _wrap_Node_InsertAttributeBefore},
8243  {"AppendChild", _wrap_Node_AppendChild},
8244  {"PrependChild", _wrap_Node_PrependChild},
8245  {"InsertChildAfter", _wrap_Node_InsertChildAfter},
8246  {"InsertChildBefore", _wrap_Node_InsertChildBefore},
8247  {"AppendCopy", _wrap_Node_AppendCopy},
8248  {"PrependCopy", _wrap_Node_PrependCopy},
8249  {"InsertCopyAfter", _wrap_Node_InsertCopyAfter},
8250  {"InsertCopyBefore", _wrap_Node_InsertCopyBefore},
8251  {"RemoveAttribute", _wrap_Node_RemoveAttribute},
8252  {"RemoveChild", _wrap_Node_RemoveChild},
8253  {"FindChildbyAttribute", _wrap_Node_FindChildbyAttribute},
8254  {"Path", _wrap_Node_Path},
8255  {"FirstElementByPath", _wrap_Node_FirstElementByPath},
8256  {"Traverse", _wrap_Node_Traverse},
8257  {"FindSingleNode", _wrap_Node_FindSingleNode},
8258  {"FindNodes", _wrap_Node_FindNodes},
8259  {"Print", _wrap_Node_Print},
8260  {"begin", _wrap_Node_begin},
8261  {"end", _wrap_Node_end},
8262  {"attributes_begin", _wrap_Node_attributes_begin},
8263  {"attributes_end", _wrap_Node_attributes_end},
8264  {"GetChildren", _wrap_Node_GetChildren},
8265  {"attributes", _wrap_Node_attributes},
8266  {"OffSetDebug", _wrap_Node_OffSetDebug},
8267  {"HashValue", _wrap_Node_HashValue},
8268  {"InternalObject", _wrap_Node_InternalObject},
8269  {0,0}
8270 };
8271 static swig_lua_attribute swig_Mezzanine_XML_Node_attributes[] = {
8272  {0,0,0}
8273 };
8274 static swig_lua_class *swig_Mezzanine_XML_Node_bases[] = {0};
8275 static const char *swig_Mezzanine_XML_Node_base_names[] = {0};
8276 static swig_lua_class _wrap_class_Mezzanine_XML_Node = { "Node", &SWIGTYPE_p_Mezzanine__XML__Node,_wrap_new_Node, swig_delete_Node, swig_Mezzanine_XML_Node_methods, swig_Mezzanine_XML_Node_attributes, swig_Mezzanine_XML_Node_bases, swig_Mezzanine_XML_Node_base_names };
8277 
8278 static int _wrap_new_AttributeIterator__SWIG_0(lua_State* L) {
8279  int SWIG_arg = 0;
8280  Mezzanine::XML::AttributeIterator *result = 0 ;
8281 
8282  SWIG_check_num_args("Mezzanine::XML::AttributeIterator::AttributeIterator",0,0)
8283  result = (Mezzanine::XML::AttributeIterator *)new Mezzanine::XML::AttributeIterator();
8284  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__XML__AttributeIterator,1); SWIG_arg++;
8285  return SWIG_arg;
8286 
8287  if(0) SWIG_fail;
8288 
8289 fail:
8290  lua_error(L);
8291  return SWIG_arg;
8292 }
8293 
8294 
8295 static int _wrap_new_AttributeIterator__SWIG_1(lua_State* L) {
8296  int SWIG_arg = 0;
8297  Mezzanine::XML::Attribute *arg1 = 0 ;
8298  Mezzanine::XML::Node *arg2 = 0 ;
8299  Mezzanine::XML::AttributeIterator *result = 0 ;
8300 
8301  SWIG_check_num_args("Mezzanine::XML::AttributeIterator::AttributeIterator",2,2)
8302  if(!lua_isuserdata(L,1)) SWIG_fail_arg("Mezzanine::XML::AttributeIterator::AttributeIterator",1,"Mezzanine::XML::Attribute const &");
8303  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::AttributeIterator::AttributeIterator",2,"Mezzanine::XML::Node const &");
8304 
8305  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
8306  SWIG_fail_ptr("new_AttributeIterator",1,SWIGTYPE_p_Mezzanine__XML__Attribute);
8307  }
8308 
8309 
8310  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Node,0))){
8311  SWIG_fail_ptr("new_AttributeIterator",2,SWIGTYPE_p_Mezzanine__XML__Node);
8312  }
8313 
8315  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__XML__AttributeIterator,1); SWIG_arg++;
8316  return SWIG_arg;
8317 
8318  if(0) SWIG_fail;
8319 
8320 fail:
8321  lua_error(L);
8322  return SWIG_arg;
8323 }
8324 
8325 
8326 static int _wrap_new_AttributeIterator(lua_State* L) {
8327  int argc;
8328  int argv[3]={
8329  1,2,3
8330  };
8331 
8332  argc = lua_gettop(L);
8333  if (argc == 0) {
8334  return _wrap_new_AttributeIterator__SWIG_0(L);
8335  }
8336  if (argc == 2) {
8337  int _v;
8338  {
8339  void *ptr;
8340  if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Attribute, 0)) {
8341  _v = 0;
8342  } else {
8343  _v = 1;
8344  }
8345  }
8346  if (_v) {
8347  {
8348  void *ptr;
8349  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
8350  _v = 0;
8351  } else {
8352  _v = 1;
8353  }
8354  }
8355  if (_v) {
8356  return _wrap_new_AttributeIterator__SWIG_1(L);
8357  }
8358  }
8359  }
8360 
8361  lua_pushstring(L,"Wrong arguments for overloaded function 'new_AttributeIterator'\n"
8362  " Possible C/C++ prototypes are:\n"
8363  " Mezzanine::XML::AttributeIterator::AttributeIterator()\n"
8364  " Mezzanine::XML::AttributeIterator::AttributeIterator(Mezzanine::XML::Attribute const &,Mezzanine::XML::Node const &)\n");
8365  lua_error(L);return 0;
8366 }
8367 
8368 
8369 static int _wrap_AttributeIterator___eq(lua_State* L) {
8370  int SWIG_arg = 0;
8373  bool result;
8374 
8375  SWIG_check_num_args("Mezzanine::XML::AttributeIterator::operator ==",2,2)
8376  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::AttributeIterator::operator ==",1,"Mezzanine::XML::AttributeIterator const *");
8377  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::AttributeIterator::operator ==",2,"Mezzanine::XML::AttributeIterator const &");
8378 
8379  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator,0))){
8380  SWIG_fail_ptr("AttributeIterator___eq",1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator);
8381  }
8382 
8383 
8384  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__AttributeIterator,0))){
8385  SWIG_fail_ptr("AttributeIterator___eq",2,SWIGTYPE_p_Mezzanine__XML__AttributeIterator);
8386  }
8387 
8388  result = (bool)((Mezzanine::XML::AttributeIterator const *)arg1)->operator ==((Mezzanine::XML::AttributeIterator const &)*arg2);
8389  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
8390  return SWIG_arg;
8391 
8392  if(0) SWIG_fail;
8393 
8394 fail:
8395  lua_error(L);
8396  return SWIG_arg;
8397 }
8398 
8399 
8400 static int _wrap_AttributeIterator___ref__(lua_State* L) {
8401  int SWIG_arg = 0;
8403  Mezzanine::XML::Attribute *result = 0 ;
8404 
8405  SWIG_check_num_args("Mezzanine::XML::AttributeIterator::operator *",1,1)
8406  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::AttributeIterator::operator *",1,"Mezzanine::XML::AttributeIterator const *");
8407 
8408  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator,0))){
8409  SWIG_fail_ptr("AttributeIterator___ref__",1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator);
8410  }
8411 
8412  result = (Mezzanine::XML::Attribute *) &((Mezzanine::XML::AttributeIterator const *)arg1)->operator *();
8413  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__XML__Attribute,0); SWIG_arg++;
8414  return SWIG_arg;
8415 
8416  if(0) SWIG_fail;
8417 
8418 fail:
8419  lua_error(L);
8420  return SWIG_arg;
8421 }
8422 
8423 
8424 static int _wrap_AttributeIterator___deref__(lua_State* L) {
8425  int SWIG_arg = 0;
8427  Mezzanine::XML::Attribute *result = 0 ;
8428 
8429  SWIG_check_num_args("Mezzanine::XML::AttributeIterator::operator ->",1,1)
8430  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::AttributeIterator::operator ->",1,"Mezzanine::XML::AttributeIterator const *");
8431 
8432  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator,0))){
8433  SWIG_fail_ptr("AttributeIterator___deref__",1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator);
8434  }
8435 
8436  result = (Mezzanine::XML::Attribute *)((Mezzanine::XML::AttributeIterator const *)arg1)->operator ->();
8437  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__XML__Attribute,0); SWIG_arg++;
8438  return SWIG_arg;
8439 
8440  if(0) SWIG_fail;
8441 
8442 fail:
8443  lua_error(L);
8444  return SWIG_arg;
8445 }
8446 
8447 
8448 static int _wrap_AttributeIterator___lt(lua_State* L) {
8449  int SWIG_arg = 0;
8451  Mezzanine::XML::Attribute *arg2 = 0 ;
8452  bool result;
8453 
8454  SWIG_check_num_args("Mezzanine::XML::Attribute::operator <",2,2)
8455  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Attribute::operator <",1,"Mezzanine::XML::AttributeIterator const *");
8456  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Attribute::operator <",2,"Mezzanine::XML::Attribute const &");
8457 
8458  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator,0))){
8459  SWIG_fail_ptr("AttributeIterator___lt",1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator);
8460  }
8461 
8462 
8463  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
8464  SWIG_fail_ptr("AttributeIterator___lt",2,SWIGTYPE_p_Mezzanine__XML__Attribute);
8465  }
8466 
8467  result = (bool)(*arg1)->operator <((Mezzanine::XML::Attribute const &)*arg2);
8468  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
8469  return SWIG_arg;
8470 
8471  if(0) SWIG_fail;
8472 
8473 fail:
8474  lua_error(L);
8475  return SWIG_arg;
8476 }
8477 
8478 
8479 static int _wrap_AttributeIterator___le(lua_State* L) {
8480  int SWIG_arg = 0;
8482  Mezzanine::XML::Attribute *arg2 = 0 ;
8483  bool result;
8484 
8485  SWIG_check_num_args("Mezzanine::XML::Attribute::operator <=",2,2)
8486  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Attribute::operator <=",1,"Mezzanine::XML::AttributeIterator const *");
8487  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Attribute::operator <=",2,"Mezzanine::XML::Attribute const &");
8488 
8489  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator,0))){
8490  SWIG_fail_ptr("AttributeIterator___le",1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator);
8491  }
8492 
8493 
8494  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
8495  SWIG_fail_ptr("AttributeIterator___le",2,SWIGTYPE_p_Mezzanine__XML__Attribute);
8496  }
8497 
8498  result = (bool)(*arg1)->operator <=((Mezzanine::XML::Attribute const &)*arg2);
8499  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
8500  return SWIG_arg;
8501 
8502  if(0) SWIG_fail;
8503 
8504 fail:
8505  lua_error(L);
8506  return SWIG_arg;
8507 }
8508 
8509 
8510 static int _wrap_AttributeIterator_Empty(lua_State* L) {
8511  int SWIG_arg = 0;
8513  bool result;
8514 
8515  SWIG_check_num_args("Mezzanine::XML::Attribute::Empty",1,1)
8516  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Attribute::Empty",1,"Mezzanine::XML::AttributeIterator const *");
8517 
8518  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator,0))){
8519  SWIG_fail_ptr("AttributeIterator_Empty",1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator);
8520  }
8521 
8522  result = (bool)(*arg1)->Empty();
8523  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
8524  return SWIG_arg;
8525 
8526  if(0) SWIG_fail;
8527 
8528 fail:
8529  lua_error(L);
8530  return SWIG_arg;
8531 }
8532 
8533 
8534 static int _wrap_AttributeIterator_Name(lua_State* L) {
8535  int SWIG_arg = 0;
8537  Mezzanine::Char8 *result = 0 ;
8538 
8539  SWIG_check_num_args("Mezzanine::XML::Attribute::Name",1,1)
8540  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Attribute::Name",1,"Mezzanine::XML::AttributeIterator const *");
8541 
8542  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator,0))){
8543  SWIG_fail_ptr("AttributeIterator_Name",1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator);
8544  }
8545 
8546  result = (Mezzanine::Char8 *)(*arg1)->Name();
8547  lua_pushstring(L,(const char *)result); SWIG_arg++;
8548  return SWIG_arg;
8549 
8550  if(0) SWIG_fail;
8551 
8552 fail:
8553  lua_error(L);
8554  return SWIG_arg;
8555 }
8556 
8557 
8558 static int _wrap_AttributeIterator_Value(lua_State* L) {
8559  int SWIG_arg = 0;
8561  Mezzanine::Char8 *result = 0 ;
8562 
8563  SWIG_check_num_args("Mezzanine::XML::Attribute::Value",1,1)
8564  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Attribute::Value",1,"Mezzanine::XML::AttributeIterator const *");
8565 
8566  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator,0))){
8567  SWIG_fail_ptr("AttributeIterator_Value",1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator);
8568  }
8569 
8570  result = (Mezzanine::Char8 *)(*arg1)->Value();
8571  lua_pushstring(L,(const char *)result); SWIG_arg++;
8572  return SWIG_arg;
8573 
8574  if(0) SWIG_fail;
8575 
8576 fail:
8577  lua_error(L);
8578  return SWIG_arg;
8579 }
8580 
8581 
8582 static int _wrap_AttributeIterator_AsString__SWIG_0(lua_State* L) {
8583  int SWIG_arg = 0;
8585  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
8586  Mezzanine::Char8 *result = 0 ;
8587 
8588  SWIG_check_num_args("Mezzanine::XML::Attribute::AsString",2,2)
8589  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Attribute::AsString",1,"Mezzanine::XML::AttributeIterator const *");
8590  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Attribute::AsString",2,"Mezzanine::Char8 const *");
8591 
8592  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator,0))){
8593  SWIG_fail_ptr("AttributeIterator_AsString",1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator);
8594  }
8595 
8596  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
8597  result = (Mezzanine::Char8 *)(*arg1)->AsString((Mezzanine::Char8 const *)arg2);
8598  lua_pushstring(L,(const char *)result); SWIG_arg++;
8599  return SWIG_arg;
8600 
8601  if(0) SWIG_fail;
8602 
8603 fail:
8604  lua_error(L);
8605  return SWIG_arg;
8606 }
8607 
8608 
8609 static int _wrap_AttributeIterator_AsString__SWIG_1(lua_State* L) {
8610  int SWIG_arg = 0;
8612  Mezzanine::Char8 *result = 0 ;
8613 
8614  SWIG_check_num_args("Mezzanine::XML::Attribute::AsString",1,1)
8615  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Attribute::AsString",1,"Mezzanine::XML::AttributeIterator const *");
8616 
8617  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator,0))){
8618  SWIG_fail_ptr("AttributeIterator_AsString",1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator);
8619  }
8620 
8621  result = (Mezzanine::Char8 *)(*arg1)->AsString();
8622  lua_pushstring(L,(const char *)result); SWIG_arg++;
8623  return SWIG_arg;
8624 
8625  if(0) SWIG_fail;
8626 
8627 fail:
8628  lua_error(L);
8629  return SWIG_arg;
8630 }
8631 
8632 
8633 static int _wrap_AttributeIterator_AsString(lua_State* L) {
8634  int argc;
8635  int argv[3]={
8636  1,2,3
8637  };
8638 
8639  argc = lua_gettop(L);
8640  if (argc == 1) {
8641  int _v;
8642  {
8643  void *ptr;
8644  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__AttributeIterator, 0)) {
8645  _v = 0;
8646  } else {
8647  _v = 1;
8648  }
8649  }
8650  if (_v) {
8651  return _wrap_AttributeIterator_AsString__SWIG_1(L);
8652  }
8653  }
8654  if (argc == 2) {
8655  int _v;
8656  {
8657  void *ptr;
8658  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__AttributeIterator, 0)) {
8659  _v = 0;
8660  } else {
8661  _v = 1;
8662  }
8663  }
8664  if (_v) {
8665  {
8666  _v = SWIG_lua_isnilstring(L,argv[1]);
8667  }
8668  if (_v) {
8669  return _wrap_AttributeIterator_AsString__SWIG_0(L);
8670  }
8671  }
8672  }
8673 
8674  lua_pushstring(L,"Wrong arguments for overloaded function 'AttributeIterator_AsString'\n"
8675  " Possible C/C++ prototypes are:\n"
8676  " Mezzanine::XML::Attribute::AsString(Mezzanine::Char8 const *) const\n"
8677  " Mezzanine::XML::Attribute::AsString() const\n");
8678  lua_error(L);return 0;
8679 }
8680 
8681 
8682 static int _wrap_AttributeIterator_AsInt__SWIG_0(lua_State* L) {
8683  int SWIG_arg = 0;
8685  int arg2 ;
8686  int result;
8687 
8688  SWIG_check_num_args("Mezzanine::XML::Attribute::AsInt",2,2)
8689  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Attribute::AsInt",1,"Mezzanine::XML::AttributeIterator const *");
8690  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::XML::Attribute::AsInt",2,"int");
8691 
8692  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator,0))){
8693  SWIG_fail_ptr("AttributeIterator_AsInt",1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator);
8694  }
8695 
8696  arg2 = (int)lua_tonumber(L, 2);
8697  result = (int)(*arg1)->AsInt(arg2);
8698  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
8699  return SWIG_arg;
8700 
8701  if(0) SWIG_fail;
8702 
8703 fail:
8704  lua_error(L);
8705  return SWIG_arg;
8706 }
8707 
8708 
8709 static int _wrap_AttributeIterator_AsInt__SWIG_1(lua_State* L) {
8710  int SWIG_arg = 0;
8712  int result;
8713 
8714  SWIG_check_num_args("Mezzanine::XML::Attribute::AsInt",1,1)
8715  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Attribute::AsInt",1,"Mezzanine::XML::AttributeIterator const *");
8716 
8717  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator,0))){
8718  SWIG_fail_ptr("AttributeIterator_AsInt",1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator);
8719  }
8720 
8721  result = (int)(*arg1)->AsInt();
8722  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
8723  return SWIG_arg;
8724 
8725  if(0) SWIG_fail;
8726 
8727 fail:
8728  lua_error(L);
8729  return SWIG_arg;
8730 }
8731 
8732 
8733 static int _wrap_AttributeIterator_AsInt(lua_State* L) {
8734  int argc;
8735  int argv[3]={
8736  1,2,3
8737  };
8738 
8739  argc = lua_gettop(L);
8740  if (argc == 1) {
8741  int _v;
8742  {
8743  void *ptr;
8744  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__AttributeIterator, 0)) {
8745  _v = 0;
8746  } else {
8747  _v = 1;
8748  }
8749  }
8750  if (_v) {
8751  return _wrap_AttributeIterator_AsInt__SWIG_1(L);
8752  }
8753  }
8754  if (argc == 2) {
8755  int _v;
8756  {
8757  void *ptr;
8758  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__AttributeIterator, 0)) {
8759  _v = 0;
8760  } else {
8761  _v = 1;
8762  }
8763  }
8764  if (_v) {
8765  {
8766  _v = lua_isnumber(L,argv[1]);
8767  }
8768  if (_v) {
8769  return _wrap_AttributeIterator_AsInt__SWIG_0(L);
8770  }
8771  }
8772  }
8773 
8774  lua_pushstring(L,"Wrong arguments for overloaded function 'AttributeIterator_AsInt'\n"
8775  " Possible C/C++ prototypes are:\n"
8776  " Mezzanine::XML::Attribute::AsInt(int) const\n"
8777  " Mezzanine::XML::Attribute::AsInt() const\n");
8778  lua_error(L);return 0;
8779 }
8780 
8781 
8782 static int _wrap_AttributeIterator_AsUint__SWIG_0(lua_State* L) {
8783  int SWIG_arg = 0;
8785  unsigned int arg2 ;
8786  unsigned int result;
8787 
8788  SWIG_check_num_args("Mezzanine::XML::Attribute::AsUint",2,2)
8789  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Attribute::AsUint",1,"Mezzanine::XML::AttributeIterator const *");
8790  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::XML::Attribute::AsUint",2,"unsigned int");
8791 
8792  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator,0))){
8793  SWIG_fail_ptr("AttributeIterator_AsUint",1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator);
8794  }
8795 
8796  SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative")
8797  arg2 = (unsigned int)lua_tonumber(L, 2);
8798  result = (unsigned int)(*arg1)->AsUint(arg2);
8799  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
8800  return SWIG_arg;
8801 
8802  if(0) SWIG_fail;
8803 
8804 fail:
8805  lua_error(L);
8806  return SWIG_arg;
8807 }
8808 
8809 
8810 static int _wrap_AttributeIterator_AsUint__SWIG_1(lua_State* L) {
8811  int SWIG_arg = 0;
8813  unsigned int result;
8814 
8815  SWIG_check_num_args("Mezzanine::XML::Attribute::AsUint",1,1)
8816  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Attribute::AsUint",1,"Mezzanine::XML::AttributeIterator const *");
8817 
8818  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator,0))){
8819  SWIG_fail_ptr("AttributeIterator_AsUint",1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator);
8820  }
8821 
8822  result = (unsigned int)(*arg1)->AsUint();
8823  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
8824  return SWIG_arg;
8825 
8826  if(0) SWIG_fail;
8827 
8828 fail:
8829  lua_error(L);
8830  return SWIG_arg;
8831 }
8832 
8833 
8834 static int _wrap_AttributeIterator_AsUint(lua_State* L) {
8835  int argc;
8836  int argv[3]={
8837  1,2,3
8838  };
8839 
8840  argc = lua_gettop(L);
8841  if (argc == 1) {
8842  int _v;
8843  {
8844  void *ptr;
8845  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__AttributeIterator, 0)) {
8846  _v = 0;
8847  } else {
8848  _v = 1;
8849  }
8850  }
8851  if (_v) {
8852  return _wrap_AttributeIterator_AsUint__SWIG_1(L);
8853  }
8854  }
8855  if (argc == 2) {
8856  int _v;
8857  {
8858  void *ptr;
8859  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__AttributeIterator, 0)) {
8860  _v = 0;
8861  } else {
8862  _v = 1;
8863  }
8864  }
8865  if (_v) {
8866  {
8867  _v = lua_isnumber(L,argv[1]);
8868  }
8869  if (_v) {
8870  return _wrap_AttributeIterator_AsUint__SWIG_0(L);
8871  }
8872  }
8873  }
8874 
8875  lua_pushstring(L,"Wrong arguments for overloaded function 'AttributeIterator_AsUint'\n"
8876  " Possible C/C++ prototypes are:\n"
8877  " Mezzanine::XML::Attribute::AsUint(unsigned int) const\n"
8878  " Mezzanine::XML::Attribute::AsUint() const\n");
8879  lua_error(L);return 0;
8880 }
8881 
8882 
8883 static int _wrap_AttributeIterator_AsDouble__SWIG_0(lua_State* L) {
8884  int SWIG_arg = 0;
8886  double arg2 ;
8887  double result;
8888 
8889  SWIG_check_num_args("Mezzanine::XML::Attribute::AsDouble",2,2)
8890  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Attribute::AsDouble",1,"Mezzanine::XML::AttributeIterator const *");
8891  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::XML::Attribute::AsDouble",2,"double");
8892 
8893  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator,0))){
8894  SWIG_fail_ptr("AttributeIterator_AsDouble",1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator);
8895  }
8896 
8897  arg2 = (double)lua_tonumber(L, 2);
8898  result = (double)(*arg1)->AsDouble(arg2);
8899  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
8900  return SWIG_arg;
8901 
8902  if(0) SWIG_fail;
8903 
8904 fail:
8905  lua_error(L);
8906  return SWIG_arg;
8907 }
8908 
8909 
8910 static int _wrap_AttributeIterator_AsDouble__SWIG_1(lua_State* L) {
8911  int SWIG_arg = 0;
8913  double result;
8914 
8915  SWIG_check_num_args("Mezzanine::XML::Attribute::AsDouble",1,1)
8916  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Attribute::AsDouble",1,"Mezzanine::XML::AttributeIterator const *");
8917 
8918  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator,0))){
8919  SWIG_fail_ptr("AttributeIterator_AsDouble",1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator);
8920  }
8921 
8922  result = (double)(*arg1)->AsDouble();
8923  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
8924  return SWIG_arg;
8925 
8926  if(0) SWIG_fail;
8927 
8928 fail:
8929  lua_error(L);
8930  return SWIG_arg;
8931 }
8932 
8933 
8934 static int _wrap_AttributeIterator_AsDouble(lua_State* L) {
8935  int argc;
8936  int argv[3]={
8937  1,2,3
8938  };
8939 
8940  argc = lua_gettop(L);
8941  if (argc == 1) {
8942  int _v;
8943  {
8944  void *ptr;
8945  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__AttributeIterator, 0)) {
8946  _v = 0;
8947  } else {
8948  _v = 1;
8949  }
8950  }
8951  if (_v) {
8952  return _wrap_AttributeIterator_AsDouble__SWIG_1(L);
8953  }
8954  }
8955  if (argc == 2) {
8956  int _v;
8957  {
8958  void *ptr;
8959  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__AttributeIterator, 0)) {
8960  _v = 0;
8961  } else {
8962  _v = 1;
8963  }
8964  }
8965  if (_v) {
8966  {
8967  _v = lua_isnumber(L,argv[1]);
8968  }
8969  if (_v) {
8970  return _wrap_AttributeIterator_AsDouble__SWIG_0(L);
8971  }
8972  }
8973  }
8974 
8975  lua_pushstring(L,"Wrong arguments for overloaded function 'AttributeIterator_AsDouble'\n"
8976  " Possible C/C++ prototypes are:\n"
8977  " Mezzanine::XML::Attribute::AsDouble(double) const\n"
8978  " Mezzanine::XML::Attribute::AsDouble() const\n");
8979  lua_error(L);return 0;
8980 }
8981 
8982 
8983 static int _wrap_AttributeIterator_AsFloat__SWIG_0(lua_State* L) {
8984  int SWIG_arg = 0;
8986  float arg2 ;
8987  float result;
8988 
8989  SWIG_check_num_args("Mezzanine::XML::Attribute::AsFloat",2,2)
8990  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Attribute::AsFloat",1,"Mezzanine::XML::AttributeIterator const *");
8991  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::XML::Attribute::AsFloat",2,"float");
8992 
8993  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator,0))){
8994  SWIG_fail_ptr("AttributeIterator_AsFloat",1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator);
8995  }
8996 
8997  arg2 = (float)lua_tonumber(L, 2);
8998  result = (float)(*arg1)->AsFloat(arg2);
8999  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
9000  return SWIG_arg;
9001 
9002  if(0) SWIG_fail;
9003 
9004 fail:
9005  lua_error(L);
9006  return SWIG_arg;
9007 }
9008 
9009 
9010 static int _wrap_AttributeIterator_AsFloat__SWIG_1(lua_State* L) {
9011  int SWIG_arg = 0;
9013  float result;
9014 
9015  SWIG_check_num_args("Mezzanine::XML::Attribute::AsFloat",1,1)
9016  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Attribute::AsFloat",1,"Mezzanine::XML::AttributeIterator const *");
9017 
9018  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator,0))){
9019  SWIG_fail_ptr("AttributeIterator_AsFloat",1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator);
9020  }
9021 
9022  result = (float)(*arg1)->AsFloat();
9023  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
9024  return SWIG_arg;
9025 
9026  if(0) SWIG_fail;
9027 
9028 fail:
9029  lua_error(L);
9030  return SWIG_arg;
9031 }
9032 
9033 
9034 static int _wrap_AttributeIterator_AsFloat(lua_State* L) {
9035  int argc;
9036  int argv[3]={
9037  1,2,3
9038  };
9039 
9040  argc = lua_gettop(L);
9041  if (argc == 1) {
9042  int _v;
9043  {
9044  void *ptr;
9045  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__AttributeIterator, 0)) {
9046  _v = 0;
9047  } else {
9048  _v = 1;
9049  }
9050  }
9051  if (_v) {
9052  return _wrap_AttributeIterator_AsFloat__SWIG_1(L);
9053  }
9054  }
9055  if (argc == 2) {
9056  int _v;
9057  {
9058  void *ptr;
9059  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__AttributeIterator, 0)) {
9060  _v = 0;
9061  } else {
9062  _v = 1;
9063  }
9064  }
9065  if (_v) {
9066  {
9067  _v = lua_isnumber(L,argv[1]);
9068  }
9069  if (_v) {
9070  return _wrap_AttributeIterator_AsFloat__SWIG_0(L);
9071  }
9072  }
9073  }
9074 
9075  lua_pushstring(L,"Wrong arguments for overloaded function 'AttributeIterator_AsFloat'\n"
9076  " Possible C/C++ prototypes are:\n"
9077  " Mezzanine::XML::Attribute::AsFloat(float) const\n"
9078  " Mezzanine::XML::Attribute::AsFloat() const\n");
9079  lua_error(L);return 0;
9080 }
9081 
9082 
9083 static int _wrap_AttributeIterator_AsReal__SWIG_0(lua_State* L) {
9084  int SWIG_arg = 0;
9086  Mezzanine::Real arg2 ;
9087  Mezzanine::Real result;
9088 
9089  SWIG_check_num_args("Mezzanine::XML::Attribute::AsReal",2,2)
9090  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Attribute::AsReal",1,"Mezzanine::XML::AttributeIterator const *");
9091  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::XML::Attribute::AsReal",2,"Mezzanine::Real");
9092 
9093  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator,0))){
9094  SWIG_fail_ptr("AttributeIterator_AsReal",1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator);
9095  }
9096 
9097  arg2 = (Mezzanine::Real)lua_tonumber(L, 2);
9098  result = (Mezzanine::Real)(*arg1)->AsReal(arg2);
9099  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
9100  return SWIG_arg;
9101 
9102  if(0) SWIG_fail;
9103 
9104 fail:
9105  lua_error(L);
9106  return SWIG_arg;
9107 }
9108 
9109 
9110 static int _wrap_AttributeIterator_AsReal__SWIG_1(lua_State* L) {
9111  int SWIG_arg = 0;
9113  Mezzanine::Real result;
9114 
9115  SWIG_check_num_args("Mezzanine::XML::Attribute::AsReal",1,1)
9116  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Attribute::AsReal",1,"Mezzanine::XML::AttributeIterator const *");
9117 
9118  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator,0))){
9119  SWIG_fail_ptr("AttributeIterator_AsReal",1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator);
9120  }
9121 
9122  result = (Mezzanine::Real)(*arg1)->AsReal();
9123  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
9124  return SWIG_arg;
9125 
9126  if(0) SWIG_fail;
9127 
9128 fail:
9129  lua_error(L);
9130  return SWIG_arg;
9131 }
9132 
9133 
9134 static int _wrap_AttributeIterator_AsReal(lua_State* L) {
9135  int argc;
9136  int argv[3]={
9137  1,2,3
9138  };
9139 
9140  argc = lua_gettop(L);
9141  if (argc == 1) {
9142  int _v;
9143  {
9144  void *ptr;
9145  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__AttributeIterator, 0)) {
9146  _v = 0;
9147  } else {
9148  _v = 1;
9149  }
9150  }
9151  if (_v) {
9152  return _wrap_AttributeIterator_AsReal__SWIG_1(L);
9153  }
9154  }
9155  if (argc == 2) {
9156  int _v;
9157  {
9158  void *ptr;
9159  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__AttributeIterator, 0)) {
9160  _v = 0;
9161  } else {
9162  _v = 1;
9163  }
9164  }
9165  if (_v) {
9166  {
9167  _v = lua_isnumber(L,argv[1]);
9168  }
9169  if (_v) {
9170  return _wrap_AttributeIterator_AsReal__SWIG_0(L);
9171  }
9172  }
9173  }
9174 
9175  lua_pushstring(L,"Wrong arguments for overloaded function 'AttributeIterator_AsReal'\n"
9176  " Possible C/C++ prototypes are:\n"
9177  " Mezzanine::XML::Attribute::AsReal(Mezzanine::Real) const\n"
9178  " Mezzanine::XML::Attribute::AsReal() const\n");
9179  lua_error(L);return 0;
9180 }
9181 
9182 
9183 static int _wrap_AttributeIterator_AsWhole__SWIG_0(lua_State* L) {
9184  int SWIG_arg = 0;
9186  Mezzanine::Whole arg2 ;
9187  Mezzanine::Whole result;
9188 
9189  SWIG_check_num_args("Mezzanine::XML::Attribute::AsWhole",2,2)
9190  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Attribute::AsWhole",1,"Mezzanine::XML::AttributeIterator const *");
9191  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::XML::Attribute::AsWhole",2,"Mezzanine::Whole");
9192 
9193  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator,0))){
9194  SWIG_fail_ptr("AttributeIterator_AsWhole",1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator);
9195  }
9196 
9197  SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative")
9198  arg2 = (Mezzanine::Whole)lua_tonumber(L, 2);
9199  result = (Mezzanine::Whole)(*arg1)->AsWhole(arg2);
9200  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
9201  return SWIG_arg;
9202 
9203  if(0) SWIG_fail;
9204 
9205 fail:
9206  lua_error(L);
9207  return SWIG_arg;
9208 }
9209 
9210 
9211 static int _wrap_AttributeIterator_AsWhole__SWIG_1(lua_State* L) {
9212  int SWIG_arg = 0;
9214  Mezzanine::Whole result;
9215 
9216  SWIG_check_num_args("Mezzanine::XML::Attribute::AsWhole",1,1)
9217  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Attribute::AsWhole",1,"Mezzanine::XML::AttributeIterator const *");
9218 
9219  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator,0))){
9220  SWIG_fail_ptr("AttributeIterator_AsWhole",1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator);
9221  }
9222 
9223  result = (Mezzanine::Whole)(*arg1)->AsWhole();
9224  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
9225  return SWIG_arg;
9226 
9227  if(0) SWIG_fail;
9228 
9229 fail:
9230  lua_error(L);
9231  return SWIG_arg;
9232 }
9233 
9234 
9235 static int _wrap_AttributeIterator_AsWhole(lua_State* L) {
9236  int argc;
9237  int argv[3]={
9238  1,2,3
9239  };
9240 
9241  argc = lua_gettop(L);
9242  if (argc == 1) {
9243  int _v;
9244  {
9245  void *ptr;
9246  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__AttributeIterator, 0)) {
9247  _v = 0;
9248  } else {
9249  _v = 1;
9250  }
9251  }
9252  if (_v) {
9253  return _wrap_AttributeIterator_AsWhole__SWIG_1(L);
9254  }
9255  }
9256  if (argc == 2) {
9257  int _v;
9258  {
9259  void *ptr;
9260  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__AttributeIterator, 0)) {
9261  _v = 0;
9262  } else {
9263  _v = 1;
9264  }
9265  }
9266  if (_v) {
9267  {
9268  _v = lua_isnumber(L,argv[1]);
9269  }
9270  if (_v) {
9271  return _wrap_AttributeIterator_AsWhole__SWIG_0(L);
9272  }
9273  }
9274  }
9275 
9276  lua_pushstring(L,"Wrong arguments for overloaded function 'AttributeIterator_AsWhole'\n"
9277  " Possible C/C++ prototypes are:\n"
9278  " Mezzanine::XML::Attribute::AsWhole(Mezzanine::Whole) const\n"
9279  " Mezzanine::XML::Attribute::AsWhole() const\n");
9280  lua_error(L);return 0;
9281 }
9282 
9283 
9284 static int _wrap_AttributeIterator_AsInteger__SWIG_0(lua_State* L) {
9285  int SWIG_arg = 0;
9287  Mezzanine::Integer arg2 ;
9288  Mezzanine::Integer result;
9289 
9290  SWIG_check_num_args("Mezzanine::XML::Attribute::AsInteger",2,2)
9291  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Attribute::AsInteger",1,"Mezzanine::XML::AttributeIterator const *");
9292  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::XML::Attribute::AsInteger",2,"Mezzanine::Integer");
9293 
9294  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator,0))){
9295  SWIG_fail_ptr("AttributeIterator_AsInteger",1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator);
9296  }
9297 
9298  arg2 = (Mezzanine::Integer)lua_tonumber(L, 2);
9299  result = (Mezzanine::Integer)(*arg1)->AsInteger(arg2);
9300  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
9301  return SWIG_arg;
9302 
9303  if(0) SWIG_fail;
9304 
9305 fail:
9306  lua_error(L);
9307  return SWIG_arg;
9308 }
9309 
9310 
9311 static int _wrap_AttributeIterator_AsInteger__SWIG_1(lua_State* L) {
9312  int SWIG_arg = 0;
9314  Mezzanine::Integer result;
9315 
9316  SWIG_check_num_args("Mezzanine::XML::Attribute::AsInteger",1,1)
9317  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Attribute::AsInteger",1,"Mezzanine::XML::AttributeIterator const *");
9318 
9319  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator,0))){
9320  SWIG_fail_ptr("AttributeIterator_AsInteger",1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator);
9321  }
9322 
9323  result = (Mezzanine::Integer)(*arg1)->AsInteger();
9324  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
9325  return SWIG_arg;
9326 
9327  if(0) SWIG_fail;
9328 
9329 fail:
9330  lua_error(L);
9331  return SWIG_arg;
9332 }
9333 
9334 
9335 static int _wrap_AttributeIterator_AsInteger(lua_State* L) {
9336  int argc;
9337  int argv[3]={
9338  1,2,3
9339  };
9340 
9341  argc = lua_gettop(L);
9342  if (argc == 1) {
9343  int _v;
9344  {
9345  void *ptr;
9346  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__AttributeIterator, 0)) {
9347  _v = 0;
9348  } else {
9349  _v = 1;
9350  }
9351  }
9352  if (_v) {
9353  return _wrap_AttributeIterator_AsInteger__SWIG_1(L);
9354  }
9355  }
9356  if (argc == 2) {
9357  int _v;
9358  {
9359  void *ptr;
9360  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__AttributeIterator, 0)) {
9361  _v = 0;
9362  } else {
9363  _v = 1;
9364  }
9365  }
9366  if (_v) {
9367  {
9368  _v = lua_isnumber(L,argv[1]);
9369  }
9370  if (_v) {
9371  return _wrap_AttributeIterator_AsInteger__SWIG_0(L);
9372  }
9373  }
9374  }
9375 
9376  lua_pushstring(L,"Wrong arguments for overloaded function 'AttributeIterator_AsInteger'\n"
9377  " Possible C/C++ prototypes are:\n"
9378  " Mezzanine::XML::Attribute::AsInteger(Mezzanine::Integer) const\n"
9379  " Mezzanine::XML::Attribute::AsInteger() const\n");
9380  lua_error(L);return 0;
9381 }
9382 
9383 
9384 static int _wrap_AttributeIterator_AsBool__SWIG_0(lua_State* L) {
9385  int SWIG_arg = 0;
9387  bool arg2 ;
9388  bool result;
9389 
9390  SWIG_check_num_args("Mezzanine::XML::Attribute::AsBool",2,2)
9391  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Attribute::AsBool",1,"Mezzanine::XML::AttributeIterator const *");
9392  if(!lua_isboolean(L,2)) SWIG_fail_arg("Mezzanine::XML::Attribute::AsBool",2,"bool");
9393 
9394  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator,0))){
9395  SWIG_fail_ptr("AttributeIterator_AsBool",1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator);
9396  }
9397 
9398  arg2 = (lua_toboolean(L, 2)!=0);
9399  result = (bool)(*arg1)->AsBool(arg2);
9400  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
9401  return SWIG_arg;
9402 
9403  if(0) SWIG_fail;
9404 
9405 fail:
9406  lua_error(L);
9407  return SWIG_arg;
9408 }
9409 
9410 
9411 static int _wrap_AttributeIterator_AsBool__SWIG_1(lua_State* L) {
9412  int SWIG_arg = 0;
9414  bool result;
9415 
9416  SWIG_check_num_args("Mezzanine::XML::Attribute::AsBool",1,1)
9417  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Attribute::AsBool",1,"Mezzanine::XML::AttributeIterator const *");
9418 
9419  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator,0))){
9420  SWIG_fail_ptr("AttributeIterator_AsBool",1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator);
9421  }
9422 
9423  result = (bool)(*arg1)->AsBool();
9424  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
9425  return SWIG_arg;
9426 
9427  if(0) SWIG_fail;
9428 
9429 fail:
9430  lua_error(L);
9431  return SWIG_arg;
9432 }
9433 
9434 
9435 static int _wrap_AttributeIterator_AsBool(lua_State* L) {
9436  int argc;
9437  int argv[3]={
9438  1,2,3
9439  };
9440 
9441  argc = lua_gettop(L);
9442  if (argc == 1) {
9443  int _v;
9444  {
9445  void *ptr;
9446  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__AttributeIterator, 0)) {
9447  _v = 0;
9448  } else {
9449  _v = 1;
9450  }
9451  }
9452  if (_v) {
9453  return _wrap_AttributeIterator_AsBool__SWIG_1(L);
9454  }
9455  }
9456  if (argc == 2) {
9457  int _v;
9458  {
9459  void *ptr;
9460  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__AttributeIterator, 0)) {
9461  _v = 0;
9462  } else {
9463  _v = 1;
9464  }
9465  }
9466  if (_v) {
9467  {
9468  _v = lua_isboolean(L,argv[1]);
9469  }
9470  if (_v) {
9471  return _wrap_AttributeIterator_AsBool__SWIG_0(L);
9472  }
9473  }
9474  }
9475 
9476  lua_pushstring(L,"Wrong arguments for overloaded function 'AttributeIterator_AsBool'\n"
9477  " Possible C/C++ prototypes are:\n"
9478  " Mezzanine::XML::Attribute::AsBool(bool) const\n"
9479  " Mezzanine::XML::Attribute::AsBool() const\n");
9480  lua_error(L);return 0;
9481 }
9482 
9483 
9484 static int _wrap_AttributeIterator_SetName(lua_State* L) {
9485  int SWIG_arg = 0;
9487  Mezzanine::String *arg2 = 0 ;
9488  Mezzanine::String temp2 ;
9489  bool result;
9490 
9491  SWIG_check_num_args("Mezzanine::XML::Attribute::SetName",2,2)
9492  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Attribute::SetName",1,"Mezzanine::XML::AttributeIterator *");
9493  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Attribute::SetName",2,"Mezzanine::String const &");
9494 
9495  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator,0))){
9496  SWIG_fail_ptr("AttributeIterator_SetName",1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator);
9497  }
9498 
9499  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
9500  result = (bool)(*arg1)->SetName((Mezzanine::String const &)*arg2);
9501  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
9502  return SWIG_arg;
9503 
9504  if(0) SWIG_fail;
9505 
9506 fail:
9507  lua_error(L);
9508  return SWIG_arg;
9509 }
9510 
9511 
9512 static int _wrap_AttributeIterator_SetValue(lua_State* L) {
9513  int SWIG_arg = 0;
9515  Mezzanine::String *arg2 = 0 ;
9516  Mezzanine::String temp2 ;
9517  bool result;
9518 
9519  SWIG_check_num_args("Mezzanine::XML::Attribute::SetValue",2,2)
9520  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Attribute::SetValue",1,"Mezzanine::XML::AttributeIterator *");
9521  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Attribute::SetValue",2,"Mezzanine::String const &");
9522 
9523  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator,0))){
9524  SWIG_fail_ptr("AttributeIterator_SetValue",1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator);
9525  }
9526 
9527  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
9528  result = (bool)(*arg1)->SetValue((Mezzanine::String const &)*arg2);
9529  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
9530  return SWIG_arg;
9531 
9532  if(0) SWIG_fail;
9533 
9534 fail:
9535  lua_error(L);
9536  return SWIG_arg;
9537 }
9538 
9539 
9540 static int _wrap_AttributeIterator_GetNextAttribute(lua_State* L) {
9541  int SWIG_arg = 0;
9544 
9545  SWIG_check_num_args("Mezzanine::XML::Attribute::GetNextAttribute",1,1)
9546  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Attribute::GetNextAttribute",1,"Mezzanine::XML::AttributeIterator const *");
9547 
9548  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator,0))){
9549  SWIG_fail_ptr("AttributeIterator_GetNextAttribute",1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator);
9550  }
9551 
9552  result = (*arg1)->GetNextAttribute();
9553  {
9555  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Attribute,1); SWIG_arg++;
9556  }
9557  return SWIG_arg;
9558 
9559  if(0) SWIG_fail;
9560 
9561 fail:
9562  lua_error(L);
9563  return SWIG_arg;
9564 }
9565 
9566 
9567 static int _wrap_AttributeIterator_GetPreviousAttribute(lua_State* L) {
9568  int SWIG_arg = 0;
9571 
9572  SWIG_check_num_args("Mezzanine::XML::Attribute::GetPreviousAttribute",1,1)
9573  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Attribute::GetPreviousAttribute",1,"Mezzanine::XML::AttributeIterator const *");
9574 
9575  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator,0))){
9576  SWIG_fail_ptr("AttributeIterator_GetPreviousAttribute",1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator);
9577  }
9578 
9579  result = (*arg1)->GetPreviousAttribute();
9580  {
9582  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Attribute,1); SWIG_arg++;
9583  }
9584  return SWIG_arg;
9585 
9586  if(0) SWIG_fail;
9587 
9588 fail:
9589  lua_error(L);
9590  return SWIG_arg;
9591 }
9592 
9593 
9594 static int _wrap_AttributeIterator_HashValue(lua_State* L) {
9595  int SWIG_arg = 0;
9597  size_t result;
9598 
9599  SWIG_check_num_args("Mezzanine::XML::Attribute::HashValue",1,1)
9600  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Attribute::HashValue",1,"Mezzanine::XML::AttributeIterator const *");
9601 
9602  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator,0))){
9603  SWIG_fail_ptr("AttributeIterator_HashValue",1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator);
9604  }
9605 
9606  result = (*arg1)->HashValue();
9607  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
9608  return SWIG_arg;
9609 
9610  if(0) SWIG_fail;
9611 
9612 fail:
9613  lua_error(L);
9614  return SWIG_arg;
9615 }
9616 
9617 
9618 static int _wrap_AttributeIterator_InternalObject(lua_State* L) {
9619  int SWIG_arg = 0;
9621  Mezzanine::XML::AttributeStruct *result = 0 ;
9622 
9623  SWIG_check_num_args("Mezzanine::XML::Attribute::InternalObject",1,1)
9624  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Attribute::InternalObject",1,"Mezzanine::XML::AttributeIterator const *");
9625 
9626  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator,0))){
9627  SWIG_fail_ptr("AttributeIterator_InternalObject",1,SWIGTYPE_p_Mezzanine__XML__AttributeIterator);
9628  }
9629 
9630  result = (Mezzanine::XML::AttributeStruct *)(*arg1)->InternalObject();
9631  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__XML__AttributeStruct,0); SWIG_arg++;
9632  return SWIG_arg;
9633 
9634  if(0) SWIG_fail;
9635 
9636 fail:
9637  lua_error(L);
9638  return SWIG_arg;
9639 }
9640 
9641 
9642 static void swig_delete_AttributeIterator(void *obj) {
9644 delete arg1;
9645 }
9646 static swig_lua_method swig_Mezzanine_XML_AttributeIterator_methods[] = {
9647  {"__eq", _wrap_AttributeIterator___eq},
9648  {"__ref__", _wrap_AttributeIterator___ref__},
9649  {"__deref__", _wrap_AttributeIterator___deref__},
9650  {"__lt", _wrap_AttributeIterator___lt},
9651  {"__le", _wrap_AttributeIterator___le},
9652  {"Empty", _wrap_AttributeIterator_Empty},
9653  {"Name", _wrap_AttributeIterator_Name},
9654  {"Value", _wrap_AttributeIterator_Value},
9655  {"AsString", _wrap_AttributeIterator_AsString},
9656  {"AsInt", _wrap_AttributeIterator_AsInt},
9657  {"AsUint", _wrap_AttributeIterator_AsUint},
9658  {"AsDouble", _wrap_AttributeIterator_AsDouble},
9659  {"AsFloat", _wrap_AttributeIterator_AsFloat},
9660  {"AsReal", _wrap_AttributeIterator_AsReal},
9661  {"AsWhole", _wrap_AttributeIterator_AsWhole},
9662  {"AsInteger", _wrap_AttributeIterator_AsInteger},
9663  {"AsBool", _wrap_AttributeIterator_AsBool},
9664  {"SetName", _wrap_AttributeIterator_SetName},
9665  {"SetValue", _wrap_AttributeIterator_SetValue},
9666  {"GetNextAttribute", _wrap_AttributeIterator_GetNextAttribute},
9667  {"GetPreviousAttribute", _wrap_AttributeIterator_GetPreviousAttribute},
9668  {"HashValue", _wrap_AttributeIterator_HashValue},
9669  {"InternalObject", _wrap_AttributeIterator_InternalObject},
9670  {0,0}
9671 };
9672 static swig_lua_attribute swig_Mezzanine_XML_AttributeIterator_attributes[] = {
9673  {0,0,0}
9674 };
9675 static swig_lua_class *swig_Mezzanine_XML_AttributeIterator_bases[] = {0};
9676 static const char *swig_Mezzanine_XML_AttributeIterator_base_names[] = {0};
9677 static swig_lua_class _wrap_class_Mezzanine_XML_AttributeIterator = { "AttributeIterator", &SWIGTYPE_p_Mezzanine__XML__AttributeIterator,_wrap_new_AttributeIterator, swig_delete_AttributeIterator, swig_Mezzanine_XML_AttributeIterator_methods, swig_Mezzanine_XML_AttributeIterator_attributes, swig_Mezzanine_XML_AttributeIterator_bases, swig_Mezzanine_XML_AttributeIterator_base_names };
9678 
9679 static int _wrap_ParseResult_Status_set(lua_State* L) {
9680  int SWIG_arg = 0;
9683 
9684  SWIG_check_num_args("Mezzanine::XML::ParseResult::Status",2,2)
9685  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::ParseResult::Status",1,"Mezzanine::XML::ParseResult *");
9686  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::XML::ParseResult::Status",2,"Mezzanine::XML::ParseStatus");
9687 
9688  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__ParseResult,0))){
9689  SWIG_fail_ptr("ParseResult_Status_set",1,SWIGTYPE_p_Mezzanine__XML__ParseResult);
9690  }
9691 
9692  arg2 = (Mezzanine::XML::ParseStatus)(int)lua_tonumber(L, 2);
9693  if (arg1) (arg1)->Status = arg2;
9694 
9695  return SWIG_arg;
9696 
9697  if(0) SWIG_fail;
9698 
9699 fail:
9700  lua_error(L);
9701  return SWIG_arg;
9702 }
9703 
9704 
9705 static int _wrap_ParseResult_Status_get(lua_State* L) {
9706  int SWIG_arg = 0;
9709 
9710  SWIG_check_num_args("Mezzanine::XML::ParseResult::Status",1,1)
9711  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::ParseResult::Status",1,"Mezzanine::XML::ParseResult *");
9712 
9713  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__ParseResult,0))){
9714  SWIG_fail_ptr("ParseResult_Status_get",1,SWIGTYPE_p_Mezzanine__XML__ParseResult);
9715  }
9716 
9717  result = (Mezzanine::XML::ParseStatus) ((arg1)->Status);
9718  lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++;
9719  return SWIG_arg;
9720 
9721  if(0) SWIG_fail;
9722 
9723 fail:
9724  lua_error(L);
9725  return SWIG_arg;
9726 }
9727 
9728 
9729 static int _wrap_ParseResult_Offset_set(lua_State* L) {
9730  int SWIG_arg = 0;
9732  ptrdiff_t arg2 ;
9733  ptrdiff_t *argp2 ;
9734 
9735  SWIG_check_num_args("Mezzanine::XML::ParseResult::Offset",2,2)
9736  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::ParseResult::Offset",1,"Mezzanine::XML::ParseResult *");
9737  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::ParseResult::Offset",2,"ptrdiff_t");
9738 
9739  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__ParseResult,0))){
9740  SWIG_fail_ptr("ParseResult_Offset_set",1,SWIGTYPE_p_Mezzanine__XML__ParseResult);
9741  }
9742 
9743 
9744  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ptrdiff_t,0))){
9745  SWIG_fail_ptr("ParseResult_Offset_set",2,SWIGTYPE_p_ptrdiff_t);
9746  }
9747  arg2 = *argp2;
9748 
9749  if (arg1) (arg1)->Offset = arg2;
9750 
9751  return SWIG_arg;
9752 
9753  if(0) SWIG_fail;
9754 
9755 fail:
9756  lua_error(L);
9757  return SWIG_arg;
9758 }
9759 
9760 
9761 static int _wrap_ParseResult_Offset_get(lua_State* L) {
9762  int SWIG_arg = 0;
9764  ptrdiff_t result;
9765 
9766  SWIG_check_num_args("Mezzanine::XML::ParseResult::Offset",1,1)
9767  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::ParseResult::Offset",1,"Mezzanine::XML::ParseResult *");
9768 
9769  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__ParseResult,0))){
9770  SWIG_fail_ptr("ParseResult_Offset_get",1,SWIGTYPE_p_Mezzanine__XML__ParseResult);
9771  }
9772 
9773  result = ((arg1)->Offset);
9774  {
9775  ptrdiff_t * resultptr = new ptrdiff_t((const ptrdiff_t &) result);
9776  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ptrdiff_t,1); SWIG_arg++;
9777  }
9778  return SWIG_arg;
9779 
9780  if(0) SWIG_fail;
9781 
9782 fail:
9783  lua_error(L);
9784  return SWIG_arg;
9785 }
9786 
9787 
9788 static int _wrap_ParseResult_DocumentEncoding_set(lua_State* L) {
9789  int SWIG_arg = 0;
9792 
9793  SWIG_check_num_args("Mezzanine::XML::ParseResult::DocumentEncoding",2,2)
9794  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::ParseResult::DocumentEncoding",1,"Mezzanine::XML::ParseResult *");
9795  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::XML::ParseResult::DocumentEncoding",2,"Mezzanine::XML::Encoding");
9796 
9797  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__ParseResult,0))){
9798  SWIG_fail_ptr("ParseResult_DocumentEncoding_set",1,SWIGTYPE_p_Mezzanine__XML__ParseResult);
9799  }
9800 
9801  arg2 = (Mezzanine::XML::Encoding)(int)lua_tonumber(L, 2);
9802  if (arg1) (arg1)->DocumentEncoding = arg2;
9803 
9804  return SWIG_arg;
9805 
9806  if(0) SWIG_fail;
9807 
9808 fail:
9809  lua_error(L);
9810  return SWIG_arg;
9811 }
9812 
9813 
9814 static int _wrap_ParseResult_DocumentEncoding_get(lua_State* L) {
9815  int SWIG_arg = 0;
9817  Mezzanine::XML::Encoding result;
9818 
9819  SWIG_check_num_args("Mezzanine::XML::ParseResult::DocumentEncoding",1,1)
9820  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::ParseResult::DocumentEncoding",1,"Mezzanine::XML::ParseResult *");
9821 
9822  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__ParseResult,0))){
9823  SWIG_fail_ptr("ParseResult_DocumentEncoding_get",1,SWIGTYPE_p_Mezzanine__XML__ParseResult);
9824  }
9825 
9826  result = (Mezzanine::XML::Encoding) ((arg1)->DocumentEncoding);
9827  lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++;
9828  return SWIG_arg;
9829 
9830  if(0) SWIG_fail;
9831 
9832 fail:
9833  lua_error(L);
9834  return SWIG_arg;
9835 }
9836 
9837 
9838 static int _wrap_new_ParseResult(lua_State* L) {
9839  int SWIG_arg = 0;
9840  Mezzanine::XML::ParseResult *result = 0 ;
9841 
9842  SWIG_check_num_args("Mezzanine::XML::ParseResult::ParseResult",0,0)
9843  result = (Mezzanine::XML::ParseResult *)new Mezzanine::XML::ParseResult();
9844  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__XML__ParseResult,1); SWIG_arg++;
9845  return SWIG_arg;
9846 
9847  if(0) SWIG_fail;
9848 
9849 fail:
9850  lua_error(L);
9851  return SWIG_arg;
9852 }
9853 
9854 
9855 static int _wrap_ParseResult_Description(lua_State* L) {
9856  int SWIG_arg = 0;
9858  char *result = 0 ;
9859 
9860  SWIG_check_num_args("Mezzanine::XML::ParseResult::Description",1,1)
9861  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::ParseResult::Description",1,"Mezzanine::XML::ParseResult const *");
9862 
9863  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__ParseResult,0))){
9864  SWIG_fail_ptr("ParseResult_Description",1,SWIGTYPE_p_Mezzanine__XML__ParseResult);
9865  }
9866 
9867  result = (char *)((Mezzanine::XML::ParseResult const *)arg1)->Description();
9868  lua_pushstring(L,(const char *)result); SWIG_arg++;
9869  return SWIG_arg;
9870 
9871  if(0) SWIG_fail;
9872 
9873 fail:
9874  lua_error(L);
9875  return SWIG_arg;
9876 }
9877 
9878 
9879 static void swig_delete_ParseResult(void *obj) {
9881 delete arg1;
9882 }
9883 static swig_lua_method swig_Mezzanine_XML_ParseResult_methods[] = {
9884  {"Description", _wrap_ParseResult_Description},
9885  {0,0}
9886 };
9887 static swig_lua_attribute swig_Mezzanine_XML_ParseResult_attributes[] = {
9888  { "Status", _wrap_ParseResult_Status_get, _wrap_ParseResult_Status_set},
9889  { "Offset", _wrap_ParseResult_Offset_get, _wrap_ParseResult_Offset_set},
9890  { "DocumentEncoding", _wrap_ParseResult_DocumentEncoding_get, _wrap_ParseResult_DocumentEncoding_set},
9891  {0,0,0}
9892 };
9893 static swig_lua_class *swig_Mezzanine_XML_ParseResult_bases[] = {0};
9894 static const char *swig_Mezzanine_XML_ParseResult_base_names[] = {0};
9895 static swig_lua_class _wrap_class_Mezzanine_XML_ParseResult = { "ParseResult", &SWIGTYPE_p_Mezzanine__XML__ParseResult,_wrap_new_ParseResult, swig_delete_ParseResult, swig_Mezzanine_XML_ParseResult_methods, swig_Mezzanine_XML_ParseResult_attributes, swig_Mezzanine_XML_ParseResult_bases, swig_Mezzanine_XML_ParseResult_base_names };
9896 
9897 static int _wrap_Writer_Write(lua_State* L) {
9898  int SWIG_arg = 0;
9900  void *arg2 = (void *) 0 ;
9901  size_t arg3 ;
9902 
9903  SWIG_check_num_args("Mezzanine::XML::Writer::Write",3,3)
9904  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Writer::Write",1,"Mezzanine::XML::Writer *");
9905  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::XML::Writer::Write",2,"void const *");
9906  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::XML::Writer::Write",3,"size_t");
9907 
9908  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Writer,0))){
9909  SWIG_fail_ptr("Writer_Write",1,SWIGTYPE_p_Mezzanine__XML__Writer);
9910  }
9911 
9912  arg2=(void *)SWIG_MustGetPtr(L,2,0,0,2,"Writer_Write");
9913  SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative")
9914  arg3 = (size_t)lua_tonumber(L, 3);
9915  (arg1)->Write((void const *)arg2,arg3);
9916 
9917  return SWIG_arg;
9918 
9919  if(0) SWIG_fail;
9920 
9921 fail:
9922  lua_error(L);
9923  return SWIG_arg;
9924 }
9925 
9926 
9927 static void swig_delete_Writer(void *obj) {
9929 delete arg1;
9930 }
9931 static swig_lua_method swig_Mezzanine_XML_Writer_methods[] = {
9932  {"Write", _wrap_Writer_Write},
9933  {0,0}
9934 };
9935 static swig_lua_attribute swig_Mezzanine_XML_Writer_attributes[] = {
9936  {0,0,0}
9937 };
9938 static swig_lua_class *swig_Mezzanine_XML_Writer_bases[] = {0};
9939 static const char *swig_Mezzanine_XML_Writer_base_names[] = {0};
9940 static swig_lua_class _wrap_class_Mezzanine_XML_Writer = { "Writer", &SWIGTYPE_p_Mezzanine__XML__Writer,0, swig_delete_Writer, swig_Mezzanine_XML_Writer_methods, swig_Mezzanine_XML_Writer_attributes, swig_Mezzanine_XML_Writer_bases, swig_Mezzanine_XML_Writer_base_names };
9941 
9942 static int _wrap_new_WriterFile(lua_State* L) {
9943  int SWIG_arg = 0;
9944  void *arg1 = (void *) 0 ;
9945  Mezzanine::XML::WriterFile *result = 0 ;
9946 
9947  SWIG_check_num_args("Mezzanine::XML::WriterFile::WriterFile",1,1)
9948  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::WriterFile::WriterFile",1,"void *");
9949  arg1=(void *)SWIG_MustGetPtr(L,1,0,0,1,"new_WriterFile");
9950  result = (Mezzanine::XML::WriterFile *)new Mezzanine::XML::WriterFile(arg1);
9951  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__XML__WriterFile,1); SWIG_arg++;
9952  return SWIG_arg;
9953 
9954  if(0) SWIG_fail;
9955 
9956 fail:
9957  lua_error(L);
9958  return SWIG_arg;
9959 }
9960 
9961 
9962 static int _wrap_WriterFile_Write(lua_State* L) {
9963  int SWIG_arg = 0;
9965  void *arg2 = (void *) 0 ;
9966  size_t arg3 ;
9967 
9968  SWIG_check_num_args("Mezzanine::XML::WriterFile::Write",3,3)
9969  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::WriterFile::Write",1,"Mezzanine::XML::WriterFile *");
9970  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::XML::WriterFile::Write",2,"void const *");
9971  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::XML::WriterFile::Write",3,"size_t");
9972 
9973  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__WriterFile,0))){
9974  SWIG_fail_ptr("WriterFile_Write",1,SWIGTYPE_p_Mezzanine__XML__WriterFile);
9975  }
9976 
9977  arg2=(void *)SWIG_MustGetPtr(L,2,0,0,2,"WriterFile_Write");
9978  SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative")
9979  arg3 = (size_t)lua_tonumber(L, 3);
9980  (arg1)->Write((void const *)arg2,arg3);
9981 
9982  return SWIG_arg;
9983 
9984  if(0) SWIG_fail;
9985 
9986 fail:
9987  lua_error(L);
9988  return SWIG_arg;
9989 }
9990 
9991 
9992 static void swig_delete_WriterFile(void *obj) {
9994 delete arg1;
9995 }
9996 static swig_lua_method swig_Mezzanine_XML_WriterFile_methods[] = {
9997  {"Write", _wrap_WriterFile_Write},
9998  {0,0}
9999 };
10000 static swig_lua_attribute swig_Mezzanine_XML_WriterFile_attributes[] = {
10001  {0,0,0}
10002 };
10003 static swig_lua_class *swig_Mezzanine_XML_WriterFile_bases[] = {0,0};
10004 static const char *swig_Mezzanine_XML_WriterFile_base_names[] = {"Mezzanine::XML::Writer *",0};
10005 static swig_lua_class _wrap_class_Mezzanine_XML_WriterFile = { "WriterFile", &SWIGTYPE_p_Mezzanine__XML__WriterFile,_wrap_new_WriterFile, swig_delete_WriterFile, swig_Mezzanine_XML_WriterFile_methods, swig_Mezzanine_XML_WriterFile_attributes, swig_Mezzanine_XML_WriterFile_bases, swig_Mezzanine_XML_WriterFile_base_names };
10006 
10007 static int _wrap_new_WriterStream__SWIG_0(lua_State* L) {
10008  int SWIG_arg = 0;
10009  std::basic_ostream< char,std::char_traits< char > > *arg1 = 0 ;
10010  Mezzanine::XML::WriterStream *result = 0 ;
10011 
10012  SWIG_check_num_args("Mezzanine::XML::WriterStream::WriterStream",1,1)
10013  if(!lua_isuserdata(L,1)) SWIG_fail_arg("Mezzanine::XML::WriterStream::WriterStream",1,"std::basic_ostream< char,std::char_traits< char > > &");
10014 
10015  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,0))){
10016  SWIG_fail_ptr("new_WriterStream",1,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t);
10017  }
10018 
10020  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__XML__WriterStream,1); SWIG_arg++;
10021  return SWIG_arg;
10022 
10023  if(0) SWIG_fail;
10024 
10025 fail:
10026  lua_error(L);
10027  return SWIG_arg;
10028 }
10029 
10030 
10031 static int _wrap_new_WriterStream__SWIG_1(lua_State* L) {
10032  int SWIG_arg = 0;
10033  std::basic_ostream< wchar_t,std::char_traits< wchar_t > > *arg1 = 0 ;
10034  Mezzanine::XML::WriterStream *result = 0 ;
10035 
10036  SWIG_check_num_args("Mezzanine::XML::WriterStream::WriterStream",1,1)
10037  if(!lua_isuserdata(L,1)) SWIG_fail_arg("Mezzanine::XML::WriterStream::WriterStream",1,"std::basic_ostream< wchar_t,std::char_traits< wchar_t > > &");
10038 
10039  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__basic_ostreamT_wchar_t_std__char_traitsT_wchar_t_t_t,0))){
10040  SWIG_fail_ptr("new_WriterStream",1,SWIGTYPE_p_std__basic_ostreamT_wchar_t_std__char_traitsT_wchar_t_t_t);
10041  }
10042 
10044  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__XML__WriterStream,1); SWIG_arg++;
10045  return SWIG_arg;
10046 
10047  if(0) SWIG_fail;
10048 
10049 fail:
10050  lua_error(L);
10051  return SWIG_arg;
10052 }
10053 
10054 
10055 static int _wrap_new_WriterStream(lua_State* L) {
10056  int argc;
10057  int argv[2]={
10058  1,2
10059  };
10060 
10061  argc = lua_gettop(L);
10062  if (argc == 1) {
10063  int _v;
10064  {
10065  void *ptr;
10066  if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0)) {
10067  _v = 0;
10068  } else {
10069  _v = 1;
10070  }
10071  }
10072  if (_v) {
10073  return _wrap_new_WriterStream__SWIG_0(L);
10074  }
10075  }
10076  if (argc == 1) {
10077  int _v;
10078  {
10079  void *ptr;
10080  if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__basic_ostreamT_wchar_t_std__char_traitsT_wchar_t_t_t, 0)) {
10081  _v = 0;
10082  } else {
10083  _v = 1;
10084  }
10085  }
10086  if (_v) {
10087  return _wrap_new_WriterStream__SWIG_1(L);
10088  }
10089  }
10090 
10091  lua_pushstring(L,"Wrong arguments for overloaded function 'new_WriterStream'\n"
10092  " Possible C/C++ prototypes are:\n"
10093  " Mezzanine::XML::WriterStream::WriterStream(std::basic_ostream< char,std::char_traits< char > > &)\n"
10094  " Mezzanine::XML::WriterStream::WriterStream(std::basic_ostream< wchar_t,std::char_traits< wchar_t > > &)\n");
10095  lua_error(L);return 0;
10096 }
10097 
10098 
10099 static int _wrap_WriterStream_Write(lua_State* L) {
10100  int SWIG_arg = 0;
10102  void *arg2 = (void *) 0 ;
10103  size_t arg3 ;
10104 
10105  SWIG_check_num_args("Mezzanine::XML::WriterStream::Write",3,3)
10106  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::WriterStream::Write",1,"Mezzanine::XML::WriterStream *");
10107  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::XML::WriterStream::Write",2,"void const *");
10108  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::XML::WriterStream::Write",3,"size_t");
10109 
10110  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__WriterStream,0))){
10111  SWIG_fail_ptr("WriterStream_Write",1,SWIGTYPE_p_Mezzanine__XML__WriterStream);
10112  }
10113 
10114  arg2=(void *)SWIG_MustGetPtr(L,2,0,0,2,"WriterStream_Write");
10115  SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative")
10116  arg3 = (size_t)lua_tonumber(L, 3);
10117  (arg1)->Write((void const *)arg2,arg3);
10118 
10119  return SWIG_arg;
10120 
10121  if(0) SWIG_fail;
10122 
10123 fail:
10124  lua_error(L);
10125  return SWIG_arg;
10126 }
10127 
10128 
10129 static void swig_delete_WriterStream(void *obj) {
10131 delete arg1;
10132 }
10133 static swig_lua_method swig_Mezzanine_XML_WriterStream_methods[] = {
10134  {"Write", _wrap_WriterStream_Write},
10135  {0,0}
10136 };
10137 static swig_lua_attribute swig_Mezzanine_XML_WriterStream_attributes[] = {
10138  {0,0,0}
10139 };
10140 static swig_lua_class *swig_Mezzanine_XML_WriterStream_bases[] = {0,0};
10141 static const char *swig_Mezzanine_XML_WriterStream_base_names[] = {"Mezzanine::XML::Writer *",0};
10142 static swig_lua_class _wrap_class_Mezzanine_XML_WriterStream = { "WriterStream", &SWIGTYPE_p_Mezzanine__XML__WriterStream,_wrap_new_WriterStream, swig_delete_WriterStream, swig_Mezzanine_XML_WriterStream_methods, swig_Mezzanine_XML_WriterStream_attributes, swig_Mezzanine_XML_WriterStream_bases, swig_Mezzanine_XML_WriterStream_base_names };
10143 
10144 static int _wrap_new_XMLStreamWrapper(lua_State* L) {
10145  int SWIG_arg = 0;
10147  Mezzanine::XML::XMLStreamWrapper *result = 0 ;
10148 
10149  SWIG_check_num_args("Mezzanine::XML::XMLStreamWrapper::XMLStreamWrapper",1,1)
10150  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::XMLStreamWrapper::XMLStreamWrapper",1,"Resource::DataStream *");
10151 
10152  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Resource__DataStream,0))){
10153  SWIG_fail_ptr("new_XMLStreamWrapper",1,SWIGTYPE_p_Resource__DataStream);
10154  }
10155 
10157  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__XML__XMLStreamWrapper,1); SWIG_arg++;
10158  return SWIG_arg;
10159 
10160  if(0) SWIG_fail;
10161 
10162 fail:
10163  lua_error(L);
10164  return SWIG_arg;
10165 }
10166 
10167 
10168 static int _wrap_XMLStreamWrapper_Write(lua_State* L) {
10169  int SWIG_arg = 0;
10171  void *arg2 = (void *) 0 ;
10172  size_t arg3 ;
10173 
10174  SWIG_check_num_args("Mezzanine::XML::XMLStreamWrapper::Write",3,3)
10175  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::XMLStreamWrapper::Write",1,"Mezzanine::XML::XMLStreamWrapper *");
10176  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::XML::XMLStreamWrapper::Write",2,"void const *");
10177  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::XML::XMLStreamWrapper::Write",3,"size_t");
10178 
10179  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__XMLStreamWrapper,0))){
10180  SWIG_fail_ptr("XMLStreamWrapper_Write",1,SWIGTYPE_p_Mezzanine__XML__XMLStreamWrapper);
10181  }
10182 
10183  arg2=(void *)SWIG_MustGetPtr(L,2,0,0,2,"XMLStreamWrapper_Write");
10184  SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative")
10185  arg3 = (size_t)lua_tonumber(L, 3);
10186  (arg1)->Write((void const *)arg2,arg3);
10187 
10188  return SWIG_arg;
10189 
10190  if(0) SWIG_fail;
10191 
10192 fail:
10193  lua_error(L);
10194  return SWIG_arg;
10195 }
10196 
10197 
10198 static void swig_delete_XMLStreamWrapper(void *obj) {
10200 delete arg1;
10201 }
10202 static swig_lua_method swig_Mezzanine_XML_XMLStreamWrapper_methods[] = {
10203  {"Write", _wrap_XMLStreamWrapper_Write},
10204  {0,0}
10205 };
10206 static swig_lua_attribute swig_Mezzanine_XML_XMLStreamWrapper_attributes[] = {
10207  {0,0,0}
10208 };
10209 static swig_lua_class *swig_Mezzanine_XML_XMLStreamWrapper_bases[] = {0,0};
10210 static const char *swig_Mezzanine_XML_XMLStreamWrapper_base_names[] = {"Mezzanine::XML::Writer *",0};
10211 static swig_lua_class _wrap_class_Mezzanine_XML_XMLStreamWrapper = { "XMLStreamWrapper", &SWIGTYPE_p_Mezzanine__XML__XMLStreamWrapper,_wrap_new_XMLStreamWrapper, swig_delete_XMLStreamWrapper, swig_Mezzanine_XML_XMLStreamWrapper_methods, swig_Mezzanine_XML_XMLStreamWrapper_attributes, swig_Mezzanine_XML_XMLStreamWrapper_bases, swig_Mezzanine_XML_XMLStreamWrapper_base_names };
10212 
10213 static int _wrap_new_Document(lua_State* L) {
10214  int SWIG_arg = 0;
10215  Mezzanine::XML::Document *result = 0 ;
10216 
10217  SWIG_check_num_args("Mezzanine::XML::Document::Document",0,0)
10218  result = (Mezzanine::XML::Document *)new Mezzanine::XML::Document();
10219  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__XML__Document,1); SWIG_arg++;
10220  return SWIG_arg;
10221 
10222  if(0) SWIG_fail;
10223 
10224 fail:
10225  lua_error(L);
10226  return SWIG_arg;
10227 }
10228 
10229 
10230 static int _wrap_Document_Reset__SWIG_0(lua_State* L) {
10231  int SWIG_arg = 0;
10233 
10234  SWIG_check_num_args("Mezzanine::XML::Document::Reset",1,1)
10235  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Document::Reset",1,"Mezzanine::XML::Document *");
10236 
10237  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Document,0))){
10238  SWIG_fail_ptr("Document_Reset",1,SWIGTYPE_p_Mezzanine__XML__Document);
10239  }
10240 
10241  (arg1)->Reset();
10242 
10243  return SWIG_arg;
10244 
10245  if(0) SWIG_fail;
10246 
10247 fail:
10248  lua_error(L);
10249  return SWIG_arg;
10250 }
10251 
10252 
10253 static int _wrap_Document_Reset__SWIG_1(lua_State* L) {
10254  int SWIG_arg = 0;
10256  Mezzanine::XML::Document *arg2 = 0 ;
10257 
10258  SWIG_check_num_args("Mezzanine::XML::Document::Reset",2,2)
10259  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Document::Reset",1,"Mezzanine::XML::Document *");
10260  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Document::Reset",2,"Mezzanine::XML::Document const &");
10261 
10262  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Document,0))){
10263  SWIG_fail_ptr("Document_Reset",1,SWIGTYPE_p_Mezzanine__XML__Document);
10264  }
10265 
10266 
10267  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Document,0))){
10268  SWIG_fail_ptr("Document_Reset",2,SWIGTYPE_p_Mezzanine__XML__Document);
10269  }
10270 
10271  (arg1)->Reset((Mezzanine::XML::Document const &)*arg2);
10272 
10273  return SWIG_arg;
10274 
10275  if(0) SWIG_fail;
10276 
10277 fail:
10278  lua_error(L);
10279  return SWIG_arg;
10280 }
10281 
10282 
10283 static int _wrap_Document_Reset(lua_State* L) {
10284  int argc;
10285  int argv[3]={
10286  1,2,3
10287  };
10288 
10289  argc = lua_gettop(L);
10290  if (argc == 1) {
10291  int _v;
10292  {
10293  void *ptr;
10294  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Document, 0)) {
10295  _v = 0;
10296  } else {
10297  _v = 1;
10298  }
10299  }
10300  if (_v) {
10301  return _wrap_Document_Reset__SWIG_0(L);
10302  }
10303  }
10304  if (argc == 2) {
10305  int _v;
10306  {
10307  void *ptr;
10308  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Document, 0)) {
10309  _v = 0;
10310  } else {
10311  _v = 1;
10312  }
10313  }
10314  if (_v) {
10315  {
10316  void *ptr;
10317  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Document, 0)) {
10318  _v = 0;
10319  } else {
10320  _v = 1;
10321  }
10322  }
10323  if (_v) {
10324  return _wrap_Document_Reset__SWIG_1(L);
10325  }
10326  }
10327  }
10328 
10329  lua_pushstring(L,"Wrong arguments for overloaded function 'Document_Reset'\n"
10330  " Possible C/C++ prototypes are:\n"
10331  " Mezzanine::XML::Document::Reset()\n"
10332  " Mezzanine::XML::Document::Reset(Mezzanine::XML::Document const &)\n");
10333  lua_error(L);return 0;
10334 }
10335 
10336 
10337 static int _wrap_Document_Load__SWIG_0(lua_State* L) {
10338  int SWIG_arg = 0;
10340  Resource::DataStream *arg2 = 0 ;
10341  unsigned int arg3 ;
10344 
10345  SWIG_check_num_args("Mezzanine::XML::Document::Load",4,4)
10346  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Document::Load",1,"Mezzanine::XML::Document *");
10347  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Document::Load",2,"Resource::DataStream &");
10348  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::XML::Document::Load",3,"unsigned int");
10349  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::XML::Document::Load",4,"Mezzanine::XML::Encoding");
10350 
10351  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Document,0))){
10352  SWIG_fail_ptr("Document_Load",1,SWIGTYPE_p_Mezzanine__XML__Document);
10353  }
10354 
10355 
10356  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Resource__DataStream,0))){
10357  SWIG_fail_ptr("Document_Load",2,SWIGTYPE_p_Resource__DataStream);
10358  }
10359 
10360  SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative")
10361  arg3 = (unsigned int)lua_tonumber(L, 3);
10362  arg4 = (Mezzanine::XML::Encoding)(int)lua_tonumber(L, 4);
10363  result = (arg1)->Load(*arg2,arg3,arg4);
10364  {
10366  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__ParseResult,1); SWIG_arg++;
10367  }
10368  return SWIG_arg;
10369 
10370  if(0) SWIG_fail;
10371 
10372 fail:
10373  lua_error(L);
10374  return SWIG_arg;
10375 }
10376 
10377 
10378 static int _wrap_Document_Load__SWIG_1(lua_State* L) {
10379  int SWIG_arg = 0;
10381  Resource::DataStream *arg2 = 0 ;
10382  unsigned int arg3 ;
10384 
10385  SWIG_check_num_args("Mezzanine::XML::Document::Load",3,3)
10386  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Document::Load",1,"Mezzanine::XML::Document *");
10387  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Document::Load",2,"Resource::DataStream &");
10388  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::XML::Document::Load",3,"unsigned int");
10389 
10390  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Document,0))){
10391  SWIG_fail_ptr("Document_Load",1,SWIGTYPE_p_Mezzanine__XML__Document);
10392  }
10393 
10394 
10395  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Resource__DataStream,0))){
10396  SWIG_fail_ptr("Document_Load",2,SWIGTYPE_p_Resource__DataStream);
10397  }
10398 
10399  SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative")
10400  arg3 = (unsigned int)lua_tonumber(L, 3);
10401  result = (arg1)->Load(*arg2,arg3);
10402  {
10404  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__ParseResult,1); SWIG_arg++;
10405  }
10406  return SWIG_arg;
10407 
10408  if(0) SWIG_fail;
10409 
10410 fail:
10411  lua_error(L);
10412  return SWIG_arg;
10413 }
10414 
10415 
10416 static int _wrap_Document_Load__SWIG_2(lua_State* L) {
10417  int SWIG_arg = 0;
10419  Resource::DataStream *arg2 = 0 ;
10421 
10422  SWIG_check_num_args("Mezzanine::XML::Document::Load",2,2)
10423  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Document::Load",1,"Mezzanine::XML::Document *");
10424  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Document::Load",2,"Resource::DataStream &");
10425 
10426  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Document,0))){
10427  SWIG_fail_ptr("Document_Load",1,SWIGTYPE_p_Mezzanine__XML__Document);
10428  }
10429 
10430 
10431  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Resource__DataStream,0))){
10432  SWIG_fail_ptr("Document_Load",2,SWIGTYPE_p_Resource__DataStream);
10433  }
10434 
10435  result = (arg1)->Load(*arg2);
10436  {
10438  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__ParseResult,1); SWIG_arg++;
10439  }
10440  return SWIG_arg;
10441 
10442  if(0) SWIG_fail;
10443 
10444 fail:
10445  lua_error(L);
10446  return SWIG_arg;
10447 }
10448 
10449 
10450 static int _wrap_Document_Load__SWIG_3(lua_State* L) {
10451  int SWIG_arg = 0;
10453  std::basic_istream< char,std::char_traits< char > > *arg2 = 0 ;
10454  unsigned int arg3 ;
10457 
10458  SWIG_check_num_args("Mezzanine::XML::Document::Load",4,4)
10459  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Document::Load",1,"Mezzanine::XML::Document *");
10460  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Document::Load",2,"std::basic_istream< char,std::char_traits< char > > &");
10461  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::XML::Document::Load",3,"unsigned int");
10462  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::XML::Document::Load",4,"Mezzanine::XML::Encoding");
10463 
10464  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Document,0))){
10465  SWIG_fail_ptr("Document_Load",1,SWIGTYPE_p_Mezzanine__XML__Document);
10466  }
10467 
10468 
10469  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t,0))){
10470  SWIG_fail_ptr("Document_Load",2,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t);
10471  }
10472 
10473  SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative")
10474  arg3 = (unsigned int)lua_tonumber(L, 3);
10475  arg4 = (Mezzanine::XML::Encoding)(int)lua_tonumber(L, 4);
10476  result = (arg1)->Load(*arg2,arg3,arg4);
10477  {
10479  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__ParseResult,1); SWIG_arg++;
10480  }
10481  return SWIG_arg;
10482 
10483  if(0) SWIG_fail;
10484 
10485 fail:
10486  lua_error(L);
10487  return SWIG_arg;
10488 }
10489 
10490 
10491 static int _wrap_Document_Load__SWIG_4(lua_State* L) {
10492  int SWIG_arg = 0;
10494  std::basic_istream< char,std::char_traits< char > > *arg2 = 0 ;
10495  unsigned int arg3 ;
10497 
10498  SWIG_check_num_args("Mezzanine::XML::Document::Load",3,3)
10499  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Document::Load",1,"Mezzanine::XML::Document *");
10500  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Document::Load",2,"std::basic_istream< char,std::char_traits< char > > &");
10501  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::XML::Document::Load",3,"unsigned int");
10502 
10503  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Document,0))){
10504  SWIG_fail_ptr("Document_Load",1,SWIGTYPE_p_Mezzanine__XML__Document);
10505  }
10506 
10507 
10508  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t,0))){
10509  SWIG_fail_ptr("Document_Load",2,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t);
10510  }
10511 
10512  SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative")
10513  arg3 = (unsigned int)lua_tonumber(L, 3);
10514  result = (arg1)->Load(*arg2,arg3);
10515  {
10517  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__ParseResult,1); SWIG_arg++;
10518  }
10519  return SWIG_arg;
10520 
10521  if(0) SWIG_fail;
10522 
10523 fail:
10524  lua_error(L);
10525  return SWIG_arg;
10526 }
10527 
10528 
10529 static int _wrap_Document_Load__SWIG_5(lua_State* L) {
10530  int SWIG_arg = 0;
10532  std::basic_istream< char,std::char_traits< char > > *arg2 = 0 ;
10534 
10535  SWIG_check_num_args("Mezzanine::XML::Document::Load",2,2)
10536  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Document::Load",1,"Mezzanine::XML::Document *");
10537  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Document::Load",2,"std::basic_istream< char,std::char_traits< char > > &");
10538 
10539  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Document,0))){
10540  SWIG_fail_ptr("Document_Load",1,SWIGTYPE_p_Mezzanine__XML__Document);
10541  }
10542 
10543 
10544  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t,0))){
10545  SWIG_fail_ptr("Document_Load",2,SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t);
10546  }
10547 
10548  result = (arg1)->Load(*arg2);
10549  {
10551  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__ParseResult,1); SWIG_arg++;
10552  }
10553  return SWIG_arg;
10554 
10555  if(0) SWIG_fail;
10556 
10557 fail:
10558  lua_error(L);
10559  return SWIG_arg;
10560 }
10561 
10562 
10563 static int _wrap_Document_Load__SWIG_6(lua_State* L) {
10564  int SWIG_arg = 0;
10566  std::basic_istream< wchar_t,std::char_traits< wchar_t > > *arg2 = 0 ;
10567  unsigned int arg3 ;
10569 
10570  SWIG_check_num_args("Mezzanine::XML::Document::Load",3,3)
10571  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Document::Load",1,"Mezzanine::XML::Document *");
10572  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Document::Load",2,"std::basic_istream< wchar_t,std::char_traits< wchar_t > > &");
10573  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::XML::Document::Load",3,"unsigned int");
10574 
10575  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Document,0))){
10576  SWIG_fail_ptr("Document_Load",1,SWIGTYPE_p_Mezzanine__XML__Document);
10577  }
10578 
10579 
10580  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__basic_istreamT_wchar_t_std__char_traitsT_wchar_t_t_t,0))){
10581  SWIG_fail_ptr("Document_Load",2,SWIGTYPE_p_std__basic_istreamT_wchar_t_std__char_traitsT_wchar_t_t_t);
10582  }
10583 
10584  SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative")
10585  arg3 = (unsigned int)lua_tonumber(L, 3);
10586  result = (arg1)->Load(*arg2,arg3);
10587  {
10589  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__ParseResult,1); SWIG_arg++;
10590  }
10591  return SWIG_arg;
10592 
10593  if(0) SWIG_fail;
10594 
10595 fail:
10596  lua_error(L);
10597  return SWIG_arg;
10598 }
10599 
10600 
10601 static int _wrap_Document_Load__SWIG_7(lua_State* L) {
10602  int SWIG_arg = 0;
10604  std::basic_istream< wchar_t,std::char_traits< wchar_t > > *arg2 = 0 ;
10606 
10607  SWIG_check_num_args("Mezzanine::XML::Document::Load",2,2)
10608  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Document::Load",1,"Mezzanine::XML::Document *");
10609  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Document::Load",2,"std::basic_istream< wchar_t,std::char_traits< wchar_t > > &");
10610 
10611  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Document,0))){
10612  SWIG_fail_ptr("Document_Load",1,SWIGTYPE_p_Mezzanine__XML__Document);
10613  }
10614 
10615 
10616  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__basic_istreamT_wchar_t_std__char_traitsT_wchar_t_t_t,0))){
10617  SWIG_fail_ptr("Document_Load",2,SWIGTYPE_p_std__basic_istreamT_wchar_t_std__char_traitsT_wchar_t_t_t);
10618  }
10619 
10620  result = (arg1)->Load(*arg2);
10621  {
10623  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__ParseResult,1); SWIG_arg++;
10624  }
10625  return SWIG_arg;
10626 
10627  if(0) SWIG_fail;
10628 
10629 fail:
10630  lua_error(L);
10631  return SWIG_arg;
10632 }
10633 
10634 
10635 static int _wrap_Document_Load__SWIG_8(lua_State* L) {
10636  int SWIG_arg = 0;
10638  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
10639  unsigned int arg3 ;
10641 
10642  SWIG_check_num_args("Mezzanine::XML::Document::Load",3,3)
10643  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Document::Load",1,"Mezzanine::XML::Document *");
10644  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Document::Load",2,"Mezzanine::Char8 const *");
10645  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::XML::Document::Load",3,"unsigned int");
10646 
10647  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Document,0))){
10648  SWIG_fail_ptr("Document_Load",1,SWIGTYPE_p_Mezzanine__XML__Document);
10649  }
10650 
10651  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
10652  SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative")
10653  arg3 = (unsigned int)lua_tonumber(L, 3);
10654  result = (arg1)->Load((Mezzanine::Char8 const *)arg2,arg3);
10655  {
10657  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__ParseResult,1); SWIG_arg++;
10658  }
10659  return SWIG_arg;
10660 
10661  if(0) SWIG_fail;
10662 
10663 fail:
10664  lua_error(L);
10665  return SWIG_arg;
10666 }
10667 
10668 
10669 static int _wrap_Document_Load__SWIG_9(lua_State* L) {
10670  int SWIG_arg = 0;
10672  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
10674 
10675  SWIG_check_num_args("Mezzanine::XML::Document::Load",2,2)
10676  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Document::Load",1,"Mezzanine::XML::Document *");
10677  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Document::Load",2,"Mezzanine::Char8 const *");
10678 
10679  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Document,0))){
10680  SWIG_fail_ptr("Document_Load",1,SWIGTYPE_p_Mezzanine__XML__Document);
10681  }
10682 
10683  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
10684  result = (arg1)->Load((Mezzanine::Char8 const *)arg2);
10685  {
10687  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__ParseResult,1); SWIG_arg++;
10688  }
10689  return SWIG_arg;
10690 
10691  if(0) SWIG_fail;
10692 
10693 fail:
10694  lua_error(L);
10695  return SWIG_arg;
10696 }
10697 
10698 
10699 static int _wrap_Document_Load(lua_State* L) {
10700  int argc;
10701  int argv[5]={
10702  1,2,3,4,5
10703  };
10704 
10705  argc = lua_gettop(L);
10706  if (argc == 2) {
10707  int _v;
10708  {
10709  void *ptr;
10710  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Document, 0)) {
10711  _v = 0;
10712  } else {
10713  _v = 1;
10714  }
10715  }
10716  if (_v) {
10717  {
10718  void *ptr;
10719  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Resource__DataStream, 0)) {
10720  _v = 0;
10721  } else {
10722  _v = 1;
10723  }
10724  }
10725  if (_v) {
10726  return _wrap_Document_Load__SWIG_2(L);
10727  }
10728  }
10729  }
10730  if (argc == 2) {
10731  int _v;
10732  {
10733  void *ptr;
10734  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Document, 0)) {
10735  _v = 0;
10736  } else {
10737  _v = 1;
10738  }
10739  }
10740  if (_v) {
10741  {
10742  void *ptr;
10743  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0)) {
10744  _v = 0;
10745  } else {
10746  _v = 1;
10747  }
10748  }
10749  if (_v) {
10750  return _wrap_Document_Load__SWIG_5(L);
10751  }
10752  }
10753  }
10754  if (argc == 2) {
10755  int _v;
10756  {
10757  void *ptr;
10758  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Document, 0)) {
10759  _v = 0;
10760  } else {
10761  _v = 1;
10762  }
10763  }
10764  if (_v) {
10765  {
10766  void *ptr;
10767  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__basic_istreamT_wchar_t_std__char_traitsT_wchar_t_t_t, 0)) {
10768  _v = 0;
10769  } else {
10770  _v = 1;
10771  }
10772  }
10773  if (_v) {
10774  return _wrap_Document_Load__SWIG_7(L);
10775  }
10776  }
10777  }
10778  if (argc == 2) {
10779  int _v;
10780  {
10781  void *ptr;
10782  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Document, 0)) {
10783  _v = 0;
10784  } else {
10785  _v = 1;
10786  }
10787  }
10788  if (_v) {
10789  {
10790  _v = SWIG_lua_isnilstring(L,argv[1]);
10791  }
10792  if (_v) {
10793  return _wrap_Document_Load__SWIG_9(L);
10794  }
10795  }
10796  }
10797  if (argc == 3) {
10798  int _v;
10799  {
10800  void *ptr;
10801  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Document, 0)) {
10802  _v = 0;
10803  } else {
10804  _v = 1;
10805  }
10806  }
10807  if (_v) {
10808  {
10809  void *ptr;
10810  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__basic_istreamT_wchar_t_std__char_traitsT_wchar_t_t_t, 0)) {
10811  _v = 0;
10812  } else {
10813  _v = 1;
10814  }
10815  }
10816  if (_v) {
10817  {
10818  _v = lua_isnumber(L,argv[2]);
10819  }
10820  if (_v) {
10821  return _wrap_Document_Load__SWIG_6(L);
10822  }
10823  }
10824  }
10825  }
10826  if (argc == 3) {
10827  int _v;
10828  {
10829  void *ptr;
10830  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Document, 0)) {
10831  _v = 0;
10832  } else {
10833  _v = 1;
10834  }
10835  }
10836  if (_v) {
10837  {
10838  void *ptr;
10839  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0)) {
10840  _v = 0;
10841  } else {
10842  _v = 1;
10843  }
10844  }
10845  if (_v) {
10846  {
10847  _v = lua_isnumber(L,argv[2]);
10848  }
10849  if (_v) {
10850  return _wrap_Document_Load__SWIG_4(L);
10851  }
10852  }
10853  }
10854  }
10855  if (argc == 3) {
10856  int _v;
10857  {
10858  void *ptr;
10859  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Document, 0)) {
10860  _v = 0;
10861  } else {
10862  _v = 1;
10863  }
10864  }
10865  if (_v) {
10866  {
10867  void *ptr;
10868  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Resource__DataStream, 0)) {
10869  _v = 0;
10870  } else {
10871  _v = 1;
10872  }
10873  }
10874  if (_v) {
10875  {
10876  _v = lua_isnumber(L,argv[2]);
10877  }
10878  if (_v) {
10879  return _wrap_Document_Load__SWIG_1(L);
10880  }
10881  }
10882  }
10883  }
10884  if (argc == 3) {
10885  int _v;
10886  {
10887  void *ptr;
10888  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Document, 0)) {
10889  _v = 0;
10890  } else {
10891  _v = 1;
10892  }
10893  }
10894  if (_v) {
10895  {
10896  _v = SWIG_lua_isnilstring(L,argv[1]);
10897  }
10898  if (_v) {
10899  {
10900  _v = lua_isnumber(L,argv[2]);
10901  }
10902  if (_v) {
10903  return _wrap_Document_Load__SWIG_8(L);
10904  }
10905  }
10906  }
10907  }
10908  if (argc == 4) {
10909  int _v;
10910  {
10911  void *ptr;
10912  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Document, 0)) {
10913  _v = 0;
10914  } else {
10915  _v = 1;
10916  }
10917  }
10918  if (_v) {
10919  {
10920  void *ptr;
10921  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Resource__DataStream, 0)) {
10922  _v = 0;
10923  } else {
10924  _v = 1;
10925  }
10926  }
10927  if (_v) {
10928  {
10929  _v = lua_isnumber(L,argv[2]);
10930  }
10931  if (_v) {
10932  {
10933  _v = lua_isnumber(L,argv[3]);
10934  }
10935  if (_v) {
10936  return _wrap_Document_Load__SWIG_0(L);
10937  }
10938  }
10939  }
10940  }
10941  }
10942  if (argc == 4) {
10943  int _v;
10944  {
10945  void *ptr;
10946  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Document, 0)) {
10947  _v = 0;
10948  } else {
10949  _v = 1;
10950  }
10951  }
10952  if (_v) {
10953  {
10954  void *ptr;
10955  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0)) {
10956  _v = 0;
10957  } else {
10958  _v = 1;
10959  }
10960  }
10961  if (_v) {
10962  {
10963  _v = lua_isnumber(L,argv[2]);
10964  }
10965  if (_v) {
10966  {
10967  _v = lua_isnumber(L,argv[3]);
10968  }
10969  if (_v) {
10970  return _wrap_Document_Load__SWIG_3(L);
10971  }
10972  }
10973  }
10974  }
10975  }
10976 
10977  lua_pushstring(L,"Wrong arguments for overloaded function 'Document_Load'\n"
10978  " Possible C/C++ prototypes are:\n"
10979  " Mezzanine::XML::Document::Load(Resource::DataStream &,unsigned int,Mezzanine::XML::Encoding)\n"
10980  " Mezzanine::XML::Document::Load(Resource::DataStream &,unsigned int)\n"
10981  " Mezzanine::XML::Document::Load(Resource::DataStream &)\n"
10982  " Mezzanine::XML::Document::Load(std::basic_istream< char,std::char_traits< char > > &,unsigned int,Mezzanine::XML::Encoding)\n"
10983  " Mezzanine::XML::Document::Load(std::basic_istream< char,std::char_traits< char > > &,unsigned int)\n"
10984  " Mezzanine::XML::Document::Load(std::basic_istream< char,std::char_traits< char > > &)\n"
10985  " Mezzanine::XML::Document::Load(std::basic_istream< wchar_t,std::char_traits< wchar_t > > &,unsigned int)\n"
10986  " Mezzanine::XML::Document::Load(std::basic_istream< wchar_t,std::char_traits< wchar_t > > &)\n"
10987  " Mezzanine::XML::Document::Load(Mezzanine::Char8 const *,unsigned int)\n"
10988  " Mezzanine::XML::Document::Load(Mezzanine::Char8 const *)\n");
10989  lua_error(L);return 0;
10990 }
10991 
10992 
10993 static int _wrap_Document_LoadFile__SWIG_0(lua_State* L) {
10994  int SWIG_arg = 0;
10996  char *arg2 = (char *) 0 ;
10997  unsigned int arg3 ;
11000 
11001  SWIG_check_num_args("Mezzanine::XML::Document::LoadFile",4,4)
11002  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Document::LoadFile",1,"Mezzanine::XML::Document *");
11003  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Document::LoadFile",2,"char const *");
11004  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::XML::Document::LoadFile",3,"unsigned int");
11005  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::XML::Document::LoadFile",4,"Mezzanine::XML::Encoding");
11006 
11007  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Document,0))){
11008  SWIG_fail_ptr("Document_LoadFile",1,SWIGTYPE_p_Mezzanine__XML__Document);
11009  }
11010 
11011  arg2 = (char *)lua_tostring(L, 2);
11012  SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative")
11013  arg3 = (unsigned int)lua_tonumber(L, 3);
11014  arg4 = (Mezzanine::XML::Encoding)(int)lua_tonumber(L, 4);
11015  result = (arg1)->LoadFile((char const *)arg2,arg3,arg4);
11016  {
11018  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__ParseResult,1); SWIG_arg++;
11019  }
11020  return SWIG_arg;
11021 
11022  if(0) SWIG_fail;
11023 
11024 fail:
11025  lua_error(L);
11026  return SWIG_arg;
11027 }
11028 
11029 
11030 static int _wrap_Document_LoadFile__SWIG_1(lua_State* L) {
11031  int SWIG_arg = 0;
11033  char *arg2 = (char *) 0 ;
11034  unsigned int arg3 ;
11036 
11037  SWIG_check_num_args("Mezzanine::XML::Document::LoadFile",3,3)
11038  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Document::LoadFile",1,"Mezzanine::XML::Document *");
11039  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Document::LoadFile",2,"char const *");
11040  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::XML::Document::LoadFile",3,"unsigned int");
11041 
11042  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Document,0))){
11043  SWIG_fail_ptr("Document_LoadFile",1,SWIGTYPE_p_Mezzanine__XML__Document);
11044  }
11045 
11046  arg2 = (char *)lua_tostring(L, 2);
11047  SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative")
11048  arg3 = (unsigned int)lua_tonumber(L, 3);
11049  result = (arg1)->LoadFile((char const *)arg2,arg3);
11050  {
11052  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__ParseResult,1); SWIG_arg++;
11053  }
11054  return SWIG_arg;
11055 
11056  if(0) SWIG_fail;
11057 
11058 fail:
11059  lua_error(L);
11060  return SWIG_arg;
11061 }
11062 
11063 
11064 static int _wrap_Document_LoadFile__SWIG_2(lua_State* L) {
11065  int SWIG_arg = 0;
11067  char *arg2 = (char *) 0 ;
11069 
11070  SWIG_check_num_args("Mezzanine::XML::Document::LoadFile",2,2)
11071  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Document::LoadFile",1,"Mezzanine::XML::Document *");
11072  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Document::LoadFile",2,"char const *");
11073 
11074  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Document,0))){
11075  SWIG_fail_ptr("Document_LoadFile",1,SWIGTYPE_p_Mezzanine__XML__Document);
11076  }
11077 
11078  arg2 = (char *)lua_tostring(L, 2);
11079  result = (arg1)->LoadFile((char const *)arg2);
11080  {
11082  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__ParseResult,1); SWIG_arg++;
11083  }
11084  return SWIG_arg;
11085 
11086  if(0) SWIG_fail;
11087 
11088 fail:
11089  lua_error(L);
11090  return SWIG_arg;
11091 }
11092 
11093 
11094 static int _wrap_Document_LoadFile__SWIG_3(lua_State* L) {
11095  int SWIG_arg = 0;
11097  wchar_t *arg2 = (wchar_t *) 0 ;
11098  unsigned int arg3 ;
11101 
11102  SWIG_check_num_args("Mezzanine::XML::Document::LoadFile",4,4)
11103  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Document::LoadFile",1,"Mezzanine::XML::Document *");
11104  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::XML::Document::LoadFile",2,"wchar_t const *");
11105  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::XML::Document::LoadFile",3,"unsigned int");
11106  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::XML::Document::LoadFile",4,"Mezzanine::XML::Encoding");
11107 
11108  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Document,0))){
11109  SWIG_fail_ptr("Document_LoadFile",1,SWIGTYPE_p_Mezzanine__XML__Document);
11110  }
11111 
11112 
11113  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_wchar_t,0))){
11114  SWIG_fail_ptr("Document_LoadFile",2,SWIGTYPE_p_wchar_t);
11115  }
11116 
11117  SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative")
11118  arg3 = (unsigned int)lua_tonumber(L, 3);
11119  arg4 = (Mezzanine::XML::Encoding)(int)lua_tonumber(L, 4);
11120  result = (arg1)->LoadFile((wchar_t const *)arg2,arg3,arg4);
11121  {
11123  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__ParseResult,1); SWIG_arg++;
11124  }
11125  return SWIG_arg;
11126 
11127  if(0) SWIG_fail;
11128 
11129 fail:
11130  lua_error(L);
11131  return SWIG_arg;
11132 }
11133 
11134 
11135 static int _wrap_Document_LoadFile__SWIG_4(lua_State* L) {
11136  int SWIG_arg = 0;
11138  wchar_t *arg2 = (wchar_t *) 0 ;
11139  unsigned int arg3 ;
11141 
11142  SWIG_check_num_args("Mezzanine::XML::Document::LoadFile",3,3)
11143  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Document::LoadFile",1,"Mezzanine::XML::Document *");
11144  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::XML::Document::LoadFile",2,"wchar_t const *");
11145  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::XML::Document::LoadFile",3,"unsigned int");
11146 
11147  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Document,0))){
11148  SWIG_fail_ptr("Document_LoadFile",1,SWIGTYPE_p_Mezzanine__XML__Document);
11149  }
11150 
11151 
11152  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_wchar_t,0))){
11153  SWIG_fail_ptr("Document_LoadFile",2,SWIGTYPE_p_wchar_t);
11154  }
11155 
11156  SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative")
11157  arg3 = (unsigned int)lua_tonumber(L, 3);
11158  result = (arg1)->LoadFile((wchar_t const *)arg2,arg3);
11159  {
11161  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__ParseResult,1); SWIG_arg++;
11162  }
11163  return SWIG_arg;
11164 
11165  if(0) SWIG_fail;
11166 
11167 fail:
11168  lua_error(L);
11169  return SWIG_arg;
11170 }
11171 
11172 
11173 static int _wrap_Document_LoadFile__SWIG_5(lua_State* L) {
11174  int SWIG_arg = 0;
11176  wchar_t *arg2 = (wchar_t *) 0 ;
11178 
11179  SWIG_check_num_args("Mezzanine::XML::Document::LoadFile",2,2)
11180  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Document::LoadFile",1,"Mezzanine::XML::Document *");
11181  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::XML::Document::LoadFile",2,"wchar_t const *");
11182 
11183  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Document,0))){
11184  SWIG_fail_ptr("Document_LoadFile",1,SWIGTYPE_p_Mezzanine__XML__Document);
11185  }
11186 
11187 
11188  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_wchar_t,0))){
11189  SWIG_fail_ptr("Document_LoadFile",2,SWIGTYPE_p_wchar_t);
11190  }
11191 
11192  result = (arg1)->LoadFile((wchar_t const *)arg2);
11193  {
11195  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__ParseResult,1); SWIG_arg++;
11196  }
11197  return SWIG_arg;
11198 
11199  if(0) SWIG_fail;
11200 
11201 fail:
11202  lua_error(L);
11203  return SWIG_arg;
11204 }
11205 
11206 
11207 static int _wrap_Document_LoadFile(lua_State* L) {
11208  int argc;
11209  int argv[5]={
11210  1,2,3,4,5
11211  };
11212 
11213  argc = lua_gettop(L);
11214  if (argc == 2) {
11215  int _v;
11216  {
11217  void *ptr;
11218  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Document, 0)) {
11219  _v = 0;
11220  } else {
11221  _v = 1;
11222  }
11223  }
11224  if (_v) {
11225  {
11226  void *ptr;
11227  if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_wchar_t, 0)) {
11228  _v = 0;
11229  } else {
11230  _v = 1;
11231  }
11232  }
11233  if (_v) {
11234  return _wrap_Document_LoadFile__SWIG_5(L);
11235  }
11236  }
11237  }
11238  if (argc == 2) {
11239  int _v;
11240  {
11241  void *ptr;
11242  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Document, 0)) {
11243  _v = 0;
11244  } else {
11245  _v = 1;
11246  }
11247  }
11248  if (_v) {
11249  {
11250  _v = SWIG_lua_isnilstring(L,argv[1]);
11251  }
11252  if (_v) {
11253  return _wrap_Document_LoadFile__SWIG_2(L);
11254  }
11255  }
11256  }
11257  if (argc == 3) {
11258  int _v;
11259  {
11260  void *ptr;
11261  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Document, 0)) {
11262  _v = 0;
11263  } else {
11264  _v = 1;
11265  }
11266  }
11267  if (_v) {
11268  {
11269  void *ptr;
11270  if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_wchar_t, 0)) {
11271  _v = 0;
11272  } else {
11273  _v = 1;
11274  }
11275  }
11276  if (_v) {
11277  {
11278  _v = lua_isnumber(L,argv[2]);
11279  }
11280  if (_v) {
11281  return _wrap_Document_LoadFile__SWIG_4(L);
11282  }
11283  }
11284  }
11285  }
11286  if (argc == 3) {
11287  int _v;
11288  {
11289  void *ptr;
11290  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Document, 0)) {
11291  _v = 0;
11292  } else {
11293  _v = 1;
11294  }
11295  }
11296  if (_v) {
11297  {
11298  _v = SWIG_lua_isnilstring(L,argv[1]);
11299  }
11300  if (_v) {
11301  {
11302  _v = lua_isnumber(L,argv[2]);
11303  }
11304  if (_v) {
11305  return _wrap_Document_LoadFile__SWIG_1(L);
11306  }
11307  }
11308  }
11309  }
11310  if (argc == 4) {
11311  int _v;
11312  {
11313  void *ptr;
11314  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Document, 0)) {
11315  _v = 0;
11316  } else {
11317  _v = 1;
11318  }
11319  }
11320  if (_v) {
11321  {
11322  void *ptr;
11323  if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_wchar_t, 0)) {
11324  _v = 0;
11325  } else {
11326  _v = 1;
11327  }
11328  }
11329  if (_v) {
11330  {
11331  _v = lua_isnumber(L,argv[2]);
11332  }
11333  if (_v) {
11334  {
11335  _v = lua_isnumber(L,argv[3]);
11336  }
11337  if (_v) {
11338  return _wrap_Document_LoadFile__SWIG_3(L);
11339  }
11340  }
11341  }
11342  }
11343  }
11344  if (argc == 4) {
11345  int _v;
11346  {
11347  void *ptr;
11348  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Document, 0)) {
11349  _v = 0;
11350  } else {
11351  _v = 1;
11352  }
11353  }
11354  if (_v) {
11355  {
11356  _v = SWIG_lua_isnilstring(L,argv[1]);
11357  }
11358  if (_v) {
11359  {
11360  _v = lua_isnumber(L,argv[2]);
11361  }
11362  if (_v) {
11363  {
11364  _v = lua_isnumber(L,argv[3]);
11365  }
11366  if (_v) {
11367  return _wrap_Document_LoadFile__SWIG_0(L);
11368  }
11369  }
11370  }
11371  }
11372  }
11373 
11374  lua_pushstring(L,"Wrong arguments for overloaded function 'Document_LoadFile'\n"
11375  " Possible C/C++ prototypes are:\n"
11376  " Mezzanine::XML::Document::LoadFile(char const *,unsigned int,Mezzanine::XML::Encoding)\n"
11377  " Mezzanine::XML::Document::LoadFile(char const *,unsigned int)\n"
11378  " Mezzanine::XML::Document::LoadFile(char const *)\n"
11379  " Mezzanine::XML::Document::LoadFile(wchar_t const *,unsigned int,Mezzanine::XML::Encoding)\n"
11380  " Mezzanine::XML::Document::LoadFile(wchar_t const *,unsigned int)\n"
11381  " Mezzanine::XML::Document::LoadFile(wchar_t const *)\n");
11382  lua_error(L);return 0;
11383 }
11384 
11385 
11386 static int _wrap_Document_LoadBuffer__SWIG_0(lua_State* L) {
11387  int SWIG_arg = 0;
11389  void *arg2 = (void *) 0 ;
11390  size_t arg3 ;
11391  unsigned int arg4 ;
11394 
11395  SWIG_check_num_args("Mezzanine::XML::Document::LoadBuffer",5,5)
11396  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Document::LoadBuffer",1,"Mezzanine::XML::Document *");
11397  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::XML::Document::LoadBuffer",2,"void const *");
11398  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::XML::Document::LoadBuffer",3,"size_t");
11399  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::XML::Document::LoadBuffer",4,"unsigned int");
11400  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::XML::Document::LoadBuffer",5,"Mezzanine::XML::Encoding");
11401 
11402  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Document,0))){
11403  SWIG_fail_ptr("Document_LoadBuffer",1,SWIGTYPE_p_Mezzanine__XML__Document);
11404  }
11405 
11406  arg2=(void *)SWIG_MustGetPtr(L,2,0,0,2,"Document_LoadBuffer");
11407  SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative")
11408  arg3 = (size_t)lua_tonumber(L, 3);
11409  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
11410  arg4 = (unsigned int)lua_tonumber(L, 4);
11411  arg5 = (Mezzanine::XML::Encoding)(int)lua_tonumber(L, 5);
11412  result = (arg1)->LoadBuffer((void const *)arg2,arg3,arg4,arg5);
11413  {
11415  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__ParseResult,1); SWIG_arg++;
11416  }
11417  return SWIG_arg;
11418 
11419  if(0) SWIG_fail;
11420 
11421 fail:
11422  lua_error(L);
11423  return SWIG_arg;
11424 }
11425 
11426 
11427 static int _wrap_Document_LoadBuffer__SWIG_1(lua_State* L) {
11428  int SWIG_arg = 0;
11430  void *arg2 = (void *) 0 ;
11431  size_t arg3 ;
11432  unsigned int arg4 ;
11434 
11435  SWIG_check_num_args("Mezzanine::XML::Document::LoadBuffer",4,4)
11436  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Document::LoadBuffer",1,"Mezzanine::XML::Document *");
11437  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::XML::Document::LoadBuffer",2,"void const *");
11438  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::XML::Document::LoadBuffer",3,"size_t");
11439  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::XML::Document::LoadBuffer",4,"unsigned int");
11440 
11441  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Document,0))){
11442  SWIG_fail_ptr("Document_LoadBuffer",1,SWIGTYPE_p_Mezzanine__XML__Document);
11443  }
11444 
11445  arg2=(void *)SWIG_MustGetPtr(L,2,0,0,2,"Document_LoadBuffer");
11446  SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative")
11447  arg3 = (size_t)lua_tonumber(L, 3);
11448  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
11449  arg4 = (unsigned int)lua_tonumber(L, 4);
11450  result = (arg1)->LoadBuffer((void const *)arg2,arg3,arg4);
11451  {
11453  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__ParseResult,1); SWIG_arg++;
11454  }
11455  return SWIG_arg;
11456 
11457  if(0) SWIG_fail;
11458 
11459 fail:
11460  lua_error(L);
11461  return SWIG_arg;
11462 }
11463 
11464 
11465 static int _wrap_Document_LoadBuffer__SWIG_2(lua_State* L) {
11466  int SWIG_arg = 0;
11468  void *arg2 = (void *) 0 ;
11469  size_t arg3 ;
11471 
11472  SWIG_check_num_args("Mezzanine::XML::Document::LoadBuffer",3,3)
11473  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Document::LoadBuffer",1,"Mezzanine::XML::Document *");
11474  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::XML::Document::LoadBuffer",2,"void const *");
11475  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::XML::Document::LoadBuffer",3,"size_t");
11476 
11477  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Document,0))){
11478  SWIG_fail_ptr("Document_LoadBuffer",1,SWIGTYPE_p_Mezzanine__XML__Document);
11479  }
11480 
11481  arg2=(void *)SWIG_MustGetPtr(L,2,0,0,2,"Document_LoadBuffer");
11482  SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative")
11483  arg3 = (size_t)lua_tonumber(L, 3);
11484  result = (arg1)->LoadBuffer((void const *)arg2,arg3);
11485  {
11487  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__ParseResult,1); SWIG_arg++;
11488  }
11489  return SWIG_arg;
11490 
11491  if(0) SWIG_fail;
11492 
11493 fail:
11494  lua_error(L);
11495  return SWIG_arg;
11496 }
11497 
11498 
11499 static int _wrap_Document_LoadBuffer(lua_State* L) {
11500  int argc;
11501  int argv[6]={
11502  1,2,3,4,5,6
11503  };
11504 
11505  argc = lua_gettop(L);
11506  if (argc == 3) {
11507  int _v;
11508  {
11509  void *ptr;
11510  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Document, 0)) {
11511  _v = 0;
11512  } else {
11513  _v = 1;
11514  }
11515  }
11516  if (_v) {
11517  {
11518  void *ptr;
11519  if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, 0, 0)) {
11520  _v = 0;
11521  } else {
11522  _v = 1;
11523  }
11524  }
11525  if (_v) {
11526  {
11527  _v = lua_isnumber(L,argv[2]);
11528  }
11529  if (_v) {
11530  return _wrap_Document_LoadBuffer__SWIG_2(L);
11531  }
11532  }
11533  }
11534  }
11535  if (argc == 4) {
11536  int _v;
11537  {
11538  void *ptr;
11539  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Document, 0)) {
11540  _v = 0;
11541  } else {
11542  _v = 1;
11543  }
11544  }
11545  if (_v) {
11546  {
11547  void *ptr;
11548  if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, 0, 0)) {
11549  _v = 0;
11550  } else {
11551  _v = 1;
11552  }
11553  }
11554  if (_v) {
11555  {
11556  _v = lua_isnumber(L,argv[2]);
11557  }
11558  if (_v) {
11559  {
11560  _v = lua_isnumber(L,argv[3]);
11561  }
11562  if (_v) {
11563  return _wrap_Document_LoadBuffer__SWIG_1(L);
11564  }
11565  }
11566  }
11567  }
11568  }
11569  if (argc == 5) {
11570  int _v;
11571  {
11572  void *ptr;
11573  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Document, 0)) {
11574  _v = 0;
11575  } else {
11576  _v = 1;
11577  }
11578  }
11579  if (_v) {
11580  {
11581  void *ptr;
11582  if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, 0, 0)) {
11583  _v = 0;
11584  } else {
11585  _v = 1;
11586  }
11587  }
11588  if (_v) {
11589  {
11590  _v = lua_isnumber(L,argv[2]);
11591  }
11592  if (_v) {
11593  {
11594  _v = lua_isnumber(L,argv[3]);
11595  }
11596  if (_v) {
11597  {
11598  _v = lua_isnumber(L,argv[4]);
11599  }
11600  if (_v) {
11601  return _wrap_Document_LoadBuffer__SWIG_0(L);
11602  }
11603  }
11604  }
11605  }
11606  }
11607  }
11608 
11609  lua_pushstring(L,"Wrong arguments for overloaded function 'Document_LoadBuffer'\n"
11610  " Possible C/C++ prototypes are:\n"
11611  " Mezzanine::XML::Document::LoadBuffer(void const *,size_t,unsigned int,Mezzanine::XML::Encoding)\n"
11612  " Mezzanine::XML::Document::LoadBuffer(void const *,size_t,unsigned int)\n"
11613  " Mezzanine::XML::Document::LoadBuffer(void const *,size_t)\n");
11614  lua_error(L);return 0;
11615 }
11616 
11617 
11618 static int _wrap_Document_LoadBufferInplace__SWIG_0(lua_State* L) {
11619  int SWIG_arg = 0;
11621  void *arg2 = (void *) 0 ;
11622  size_t arg3 ;
11623  unsigned int arg4 ;
11626 
11627  SWIG_check_num_args("Mezzanine::XML::Document::LoadBufferInplace",5,5)
11628  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Document::LoadBufferInplace",1,"Mezzanine::XML::Document *");
11629  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::XML::Document::LoadBufferInplace",2,"void *");
11630  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::XML::Document::LoadBufferInplace",3,"size_t");
11631  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::XML::Document::LoadBufferInplace",4,"unsigned int");
11632  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::XML::Document::LoadBufferInplace",5,"Mezzanine::XML::Encoding");
11633 
11634  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Document,0))){
11635  SWIG_fail_ptr("Document_LoadBufferInplace",1,SWIGTYPE_p_Mezzanine__XML__Document);
11636  }
11637 
11638  arg2=(void *)SWIG_MustGetPtr(L,2,0,0,2,"Document_LoadBufferInplace");
11639  SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative")
11640  arg3 = (size_t)lua_tonumber(L, 3);
11641  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
11642  arg4 = (unsigned int)lua_tonumber(L, 4);
11643  arg5 = (Mezzanine::XML::Encoding)(int)lua_tonumber(L, 5);
11644  result = (arg1)->LoadBufferInplace(arg2,arg3,arg4,arg5);
11645  {
11647  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__ParseResult,1); SWIG_arg++;
11648  }
11649  return SWIG_arg;
11650 
11651  if(0) SWIG_fail;
11652 
11653 fail:
11654  lua_error(L);
11655  return SWIG_arg;
11656 }
11657 
11658 
11659 static int _wrap_Document_LoadBufferInplace__SWIG_1(lua_State* L) {
11660  int SWIG_arg = 0;
11662  void *arg2 = (void *) 0 ;
11663  size_t arg3 ;
11664  unsigned int arg4 ;
11666 
11667  SWIG_check_num_args("Mezzanine::XML::Document::LoadBufferInplace",4,4)
11668  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Document::LoadBufferInplace",1,"Mezzanine::XML::Document *");
11669  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::XML::Document::LoadBufferInplace",2,"void *");
11670  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::XML::Document::LoadBufferInplace",3,"size_t");
11671  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::XML::Document::LoadBufferInplace",4,"unsigned int");
11672 
11673  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Document,0))){
11674  SWIG_fail_ptr("Document_LoadBufferInplace",1,SWIGTYPE_p_Mezzanine__XML__Document);
11675  }
11676 
11677  arg2=(void *)SWIG_MustGetPtr(L,2,0,0,2,"Document_LoadBufferInplace");
11678  SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative")
11679  arg3 = (size_t)lua_tonumber(L, 3);
11680  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
11681  arg4 = (unsigned int)lua_tonumber(L, 4);
11682  result = (arg1)->LoadBufferInplace(arg2,arg3,arg4);
11683  {
11685  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__ParseResult,1); SWIG_arg++;
11686  }
11687  return SWIG_arg;
11688 
11689  if(0) SWIG_fail;
11690 
11691 fail:
11692  lua_error(L);
11693  return SWIG_arg;
11694 }
11695 
11696 
11697 static int _wrap_Document_LoadBufferInplace__SWIG_2(lua_State* L) {
11698  int SWIG_arg = 0;
11700  void *arg2 = (void *) 0 ;
11701  size_t arg3 ;
11703 
11704  SWIG_check_num_args("Mezzanine::XML::Document::LoadBufferInplace",3,3)
11705  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Document::LoadBufferInplace",1,"Mezzanine::XML::Document *");
11706  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::XML::Document::LoadBufferInplace",2,"void *");
11707  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::XML::Document::LoadBufferInplace",3,"size_t");
11708 
11709  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Document,0))){
11710  SWIG_fail_ptr("Document_LoadBufferInplace",1,SWIGTYPE_p_Mezzanine__XML__Document);
11711  }
11712 
11713  arg2=(void *)SWIG_MustGetPtr(L,2,0,0,2,"Document_LoadBufferInplace");
11714  SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative")
11715  arg3 = (size_t)lua_tonumber(L, 3);
11716  result = (arg1)->LoadBufferInplace(arg2,arg3);
11717  {
11719  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__ParseResult,1); SWIG_arg++;
11720  }
11721  return SWIG_arg;
11722 
11723  if(0) SWIG_fail;
11724 
11725 fail:
11726  lua_error(L);
11727  return SWIG_arg;
11728 }
11729 
11730 
11731 static int _wrap_Document_LoadBufferInplace(lua_State* L) {
11732  int argc;
11733  int argv[6]={
11734  1,2,3,4,5,6
11735  };
11736 
11737  argc = lua_gettop(L);
11738  if (argc == 3) {
11739  int _v;
11740  {
11741  void *ptr;
11742  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Document, 0)) {
11743  _v = 0;
11744  } else {
11745  _v = 1;
11746  }
11747  }
11748  if (_v) {
11749  {
11750  void *ptr;
11751  if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, 0, 0)) {
11752  _v = 0;
11753  } else {
11754  _v = 1;
11755  }
11756  }
11757  if (_v) {
11758  {
11759  _v = lua_isnumber(L,argv[2]);
11760  }
11761  if (_v) {
11762  return _wrap_Document_LoadBufferInplace__SWIG_2(L);
11763  }
11764  }
11765  }
11766  }
11767  if (argc == 4) {
11768  int _v;
11769  {
11770  void *ptr;
11771  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Document, 0)) {
11772  _v = 0;
11773  } else {
11774  _v = 1;
11775  }
11776  }
11777  if (_v) {
11778  {
11779  void *ptr;
11780  if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, 0, 0)) {
11781  _v = 0;
11782  } else {
11783  _v = 1;
11784  }
11785  }
11786  if (_v) {
11787  {
11788  _v = lua_isnumber(L,argv[2]);
11789  }
11790  if (_v) {
11791  {
11792  _v = lua_isnumber(L,argv[3]);
11793  }
11794  if (_v) {
11795  return _wrap_Document_LoadBufferInplace__SWIG_1(L);
11796  }
11797  }
11798  }
11799  }
11800  }
11801  if (argc == 5) {
11802  int _v;
11803  {
11804  void *ptr;
11805  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Document, 0)) {
11806  _v = 0;
11807  } else {
11808  _v = 1;
11809  }
11810  }
11811  if (_v) {
11812  {
11813  void *ptr;
11814  if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, 0, 0)) {
11815  _v = 0;
11816  } else {
11817  _v = 1;
11818  }
11819  }
11820  if (_v) {
11821  {
11822  _v = lua_isnumber(L,argv[2]);
11823  }
11824  if (_v) {
11825  {
11826  _v = lua_isnumber(L,argv[3]);
11827  }
11828  if (_v) {
11829  {
11830  _v = lua_isnumber(L,argv[4]);
11831  }
11832  if (_v) {
11833  return _wrap_Document_LoadBufferInplace__SWIG_0(L);
11834  }
11835  }
11836  }
11837  }
11838  }
11839  }
11840 
11841  lua_pushstring(L,"Wrong arguments for overloaded function 'Document_LoadBufferInplace'\n"
11842  " Possible C/C++ prototypes are:\n"
11843  " Mezzanine::XML::Document::LoadBufferInplace(void *,size_t,unsigned int,Mezzanine::XML::Encoding)\n"
11844  " Mezzanine::XML::Document::LoadBufferInplace(void *,size_t,unsigned int)\n"
11845  " Mezzanine::XML::Document::LoadBufferInplace(void *,size_t)\n");
11846  lua_error(L);return 0;
11847 }
11848 
11849 
11850 static int _wrap_Document_LoadBufferInplaceOwn__SWIG_0(lua_State* L) {
11851  int SWIG_arg = 0;
11853  void *arg2 = (void *) 0 ;
11854  size_t arg3 ;
11855  unsigned int arg4 ;
11858 
11859  SWIG_check_num_args("Mezzanine::XML::Document::LoadBufferInplaceOwn",5,5)
11860  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Document::LoadBufferInplaceOwn",1,"Mezzanine::XML::Document *");
11861  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::XML::Document::LoadBufferInplaceOwn",2,"void *");
11862  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::XML::Document::LoadBufferInplaceOwn",3,"size_t");
11863  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::XML::Document::LoadBufferInplaceOwn",4,"unsigned int");
11864  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::XML::Document::LoadBufferInplaceOwn",5,"Mezzanine::XML::Encoding");
11865 
11866  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Document,0))){
11867  SWIG_fail_ptr("Document_LoadBufferInplaceOwn",1,SWIGTYPE_p_Mezzanine__XML__Document);
11868  }
11869 
11870  arg2=(void *)SWIG_MustGetPtr(L,2,0,0,2,"Document_LoadBufferInplaceOwn");
11871  SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative")
11872  arg3 = (size_t)lua_tonumber(L, 3);
11873  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
11874  arg4 = (unsigned int)lua_tonumber(L, 4);
11875  arg5 = (Mezzanine::XML::Encoding)(int)lua_tonumber(L, 5);
11876  result = (arg1)->LoadBufferInplaceOwn(arg2,arg3,arg4,arg5);
11877  {
11879  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__ParseResult,1); SWIG_arg++;
11880  }
11881  return SWIG_arg;
11882 
11883  if(0) SWIG_fail;
11884 
11885 fail:
11886  lua_error(L);
11887  return SWIG_arg;
11888 }
11889 
11890 
11891 static int _wrap_Document_LoadBufferInplaceOwn__SWIG_1(lua_State* L) {
11892  int SWIG_arg = 0;
11894  void *arg2 = (void *) 0 ;
11895  size_t arg3 ;
11896  unsigned int arg4 ;
11898 
11899  SWIG_check_num_args("Mezzanine::XML::Document::LoadBufferInplaceOwn",4,4)
11900  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Document::LoadBufferInplaceOwn",1,"Mezzanine::XML::Document *");
11901  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::XML::Document::LoadBufferInplaceOwn",2,"void *");
11902  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::XML::Document::LoadBufferInplaceOwn",3,"size_t");
11903  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::XML::Document::LoadBufferInplaceOwn",4,"unsigned int");
11904 
11905  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Document,0))){
11906  SWIG_fail_ptr("Document_LoadBufferInplaceOwn",1,SWIGTYPE_p_Mezzanine__XML__Document);
11907  }
11908 
11909  arg2=(void *)SWIG_MustGetPtr(L,2,0,0,2,"Document_LoadBufferInplaceOwn");
11910  SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative")
11911  arg3 = (size_t)lua_tonumber(L, 3);
11912  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
11913  arg4 = (unsigned int)lua_tonumber(L, 4);
11914  result = (arg1)->LoadBufferInplaceOwn(arg2,arg3,arg4);
11915  {
11917  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__ParseResult,1); SWIG_arg++;
11918  }
11919  return SWIG_arg;
11920 
11921  if(0) SWIG_fail;
11922 
11923 fail:
11924  lua_error(L);
11925  return SWIG_arg;
11926 }
11927 
11928 
11929 static int _wrap_Document_LoadBufferInplaceOwn__SWIG_2(lua_State* L) {
11930  int SWIG_arg = 0;
11932  void *arg2 = (void *) 0 ;
11933  size_t arg3 ;
11935 
11936  SWIG_check_num_args("Mezzanine::XML::Document::LoadBufferInplaceOwn",3,3)
11937  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Document::LoadBufferInplaceOwn",1,"Mezzanine::XML::Document *");
11938  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::XML::Document::LoadBufferInplaceOwn",2,"void *");
11939  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::XML::Document::LoadBufferInplaceOwn",3,"size_t");
11940 
11941  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Document,0))){
11942  SWIG_fail_ptr("Document_LoadBufferInplaceOwn",1,SWIGTYPE_p_Mezzanine__XML__Document);
11943  }
11944 
11945  arg2=(void *)SWIG_MustGetPtr(L,2,0,0,2,"Document_LoadBufferInplaceOwn");
11946  SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative")
11947  arg3 = (size_t)lua_tonumber(L, 3);
11948  result = (arg1)->LoadBufferInplaceOwn(arg2,arg3);
11949  {
11951  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__ParseResult,1); SWIG_arg++;
11952  }
11953  return SWIG_arg;
11954 
11955  if(0) SWIG_fail;
11956 
11957 fail:
11958  lua_error(L);
11959  return SWIG_arg;
11960 }
11961 
11962 
11963 static int _wrap_Document_LoadBufferInplaceOwn(lua_State* L) {
11964  int argc;
11965  int argv[6]={
11966  1,2,3,4,5,6
11967  };
11968 
11969  argc = lua_gettop(L);
11970  if (argc == 3) {
11971  int _v;
11972  {
11973  void *ptr;
11974  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Document, 0)) {
11975  _v = 0;
11976  } else {
11977  _v = 1;
11978  }
11979  }
11980  if (_v) {
11981  {
11982  void *ptr;
11983  if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, 0, 0)) {
11984  _v = 0;
11985  } else {
11986  _v = 1;
11987  }
11988  }
11989  if (_v) {
11990  {
11991  _v = lua_isnumber(L,argv[2]);
11992  }
11993  if (_v) {
11994  return _wrap_Document_LoadBufferInplaceOwn__SWIG_2(L);
11995  }
11996  }
11997  }
11998  }
11999  if (argc == 4) {
12000  int _v;
12001  {
12002  void *ptr;
12003  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Document, 0)) {
12004  _v = 0;
12005  } else {
12006  _v = 1;
12007  }
12008  }
12009  if (_v) {
12010  {
12011  void *ptr;
12012  if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, 0, 0)) {
12013  _v = 0;
12014  } else {
12015  _v = 1;
12016  }
12017  }
12018  if (_v) {
12019  {
12020  _v = lua_isnumber(L,argv[2]);
12021  }
12022  if (_v) {
12023  {
12024  _v = lua_isnumber(L,argv[3]);
12025  }
12026  if (_v) {
12027  return _wrap_Document_LoadBufferInplaceOwn__SWIG_1(L);
12028  }
12029  }
12030  }
12031  }
12032  }
12033  if (argc == 5) {
12034  int _v;
12035  {
12036  void *ptr;
12037  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Document, 0)) {
12038  _v = 0;
12039  } else {
12040  _v = 1;
12041  }
12042  }
12043  if (_v) {
12044  {
12045  void *ptr;
12046  if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, 0, 0)) {
12047  _v = 0;
12048  } else {
12049  _v = 1;
12050  }
12051  }
12052  if (_v) {
12053  {
12054  _v = lua_isnumber(L,argv[2]);
12055  }
12056  if (_v) {
12057  {
12058  _v = lua_isnumber(L,argv[3]);
12059  }
12060  if (_v) {
12061  {
12062  _v = lua_isnumber(L,argv[4]);
12063  }
12064  if (_v) {
12065  return _wrap_Document_LoadBufferInplaceOwn__SWIG_0(L);
12066  }
12067  }
12068  }
12069  }
12070  }
12071  }
12072 
12073  lua_pushstring(L,"Wrong arguments for overloaded function 'Document_LoadBufferInplaceOwn'\n"
12074  " Possible C/C++ prototypes are:\n"
12075  " Mezzanine::XML::Document::LoadBufferInplaceOwn(void *,size_t,unsigned int,Mezzanine::XML::Encoding)\n"
12076  " Mezzanine::XML::Document::LoadBufferInplaceOwn(void *,size_t,unsigned int)\n"
12077  " Mezzanine::XML::Document::LoadBufferInplaceOwn(void *,size_t)\n");
12078  lua_error(L);return 0;
12079 }
12080 
12081 
12082 static int _wrap_Document_Save__SWIG_0(lua_State* L) {
12083  int SWIG_arg = 0;
12085  Resource::DataStream *arg2 = 0 ;
12086  Mezzanine::Char8 *arg3 = (Mezzanine::Char8 *) 0 ;
12087  unsigned int arg4 ;
12089 
12090  SWIG_check_num_args("Mezzanine::XML::Document::Save",5,5)
12091  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Document::Save",1,"Mezzanine::XML::Document const *");
12092  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Document::Save",2,"Resource::DataStream &");
12093  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("Mezzanine::XML::Document::Save",3,"Mezzanine::Char8 const *");
12094  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::XML::Document::Save",4,"unsigned int");
12095  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::XML::Document::Save",5,"Mezzanine::XML::Encoding");
12096 
12097  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Document,0))){
12098  SWIG_fail_ptr("Document_Save",1,SWIGTYPE_p_Mezzanine__XML__Document);
12099  }
12100 
12101 
12102  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Resource__DataStream,0))){
12103  SWIG_fail_ptr("Document_Save",2,SWIGTYPE_p_Resource__DataStream);
12104  }
12105 
12106  arg3 = (Mezzanine::Char8 *)lua_tostring(L, 3);
12107  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
12108  arg4 = (unsigned int)lua_tonumber(L, 4);
12109  arg5 = (Mezzanine::XML::Encoding)(int)lua_tonumber(L, 5);
12110  ((Mezzanine::XML::Document const *)arg1)->Save(*arg2,(Mezzanine::Char8 const *)arg3,arg4,arg5);
12111 
12112  return SWIG_arg;
12113 
12114  if(0) SWIG_fail;
12115 
12116 fail:
12117  lua_error(L);
12118  return SWIG_arg;
12119 }
12120 
12121 
12122 static int _wrap_Document_Save__SWIG_1(lua_State* L) {
12123  int SWIG_arg = 0;
12125  Resource::DataStream *arg2 = 0 ;
12126  Mezzanine::Char8 *arg3 = (Mezzanine::Char8 *) 0 ;
12127  unsigned int arg4 ;
12128 
12129  SWIG_check_num_args("Mezzanine::XML::Document::Save",4,4)
12130  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Document::Save",1,"Mezzanine::XML::Document const *");
12131  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Document::Save",2,"Resource::DataStream &");
12132  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("Mezzanine::XML::Document::Save",3,"Mezzanine::Char8 const *");
12133  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::XML::Document::Save",4,"unsigned int");
12134 
12135  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Document,0))){
12136  SWIG_fail_ptr("Document_Save",1,SWIGTYPE_p_Mezzanine__XML__Document);
12137  }
12138 
12139 
12140  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Resource__DataStream,0))){
12141  SWIG_fail_ptr("Document_Save",2,SWIGTYPE_p_Resource__DataStream);
12142  }
12143 
12144  arg3 = (Mezzanine::Char8 *)lua_tostring(L, 3);
12145  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
12146  arg4 = (unsigned int)lua_tonumber(L, 4);
12147  ((Mezzanine::XML::Document const *)arg1)->Save(*arg2,(Mezzanine::Char8 const *)arg3,arg4);
12148 
12149  return SWIG_arg;
12150 
12151  if(0) SWIG_fail;
12152 
12153 fail:
12154  lua_error(L);
12155  return SWIG_arg;
12156 }
12157 
12158 
12159 static int _wrap_Document_Save__SWIG_2(lua_State* L) {
12160  int SWIG_arg = 0;
12162  Resource::DataStream *arg2 = 0 ;
12163  Mezzanine::Char8 *arg3 = (Mezzanine::Char8 *) 0 ;
12164 
12165  SWIG_check_num_args("Mezzanine::XML::Document::Save",3,3)
12166  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Document::Save",1,"Mezzanine::XML::Document const *");
12167  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Document::Save",2,"Resource::DataStream &");
12168  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("Mezzanine::XML::Document::Save",3,"Mezzanine::Char8 const *");
12169 
12170  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Document,0))){
12171  SWIG_fail_ptr("Document_Save",1,SWIGTYPE_p_Mezzanine__XML__Document);
12172  }
12173 
12174 
12175  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Resource__DataStream,0))){
12176  SWIG_fail_ptr("Document_Save",2,SWIGTYPE_p_Resource__DataStream);
12177  }
12178 
12179  arg3 = (Mezzanine::Char8 *)lua_tostring(L, 3);
12180  ((Mezzanine::XML::Document const *)arg1)->Save(*arg2,(Mezzanine::Char8 const *)arg3);
12181 
12182  return SWIG_arg;
12183 
12184  if(0) SWIG_fail;
12185 
12186 fail:
12187  lua_error(L);
12188  return SWIG_arg;
12189 }
12190 
12191 
12192 static int _wrap_Document_Save__SWIG_3(lua_State* L) {
12193  int SWIG_arg = 0;
12195  Resource::DataStream *arg2 = 0 ;
12196 
12197  SWIG_check_num_args("Mezzanine::XML::Document::Save",2,2)
12198  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Document::Save",1,"Mezzanine::XML::Document const *");
12199  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Document::Save",2,"Resource::DataStream &");
12200 
12201  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Document,0))){
12202  SWIG_fail_ptr("Document_Save",1,SWIGTYPE_p_Mezzanine__XML__Document);
12203  }
12204 
12205 
12206  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Resource__DataStream,0))){
12207  SWIG_fail_ptr("Document_Save",2,SWIGTYPE_p_Resource__DataStream);
12208  }
12209 
12210  ((Mezzanine::XML::Document const *)arg1)->Save(*arg2);
12211 
12212  return SWIG_arg;
12213 
12214  if(0) SWIG_fail;
12215 
12216 fail:
12217  lua_error(L);
12218  return SWIG_arg;
12219 }
12220 
12221 
12222 static int _wrap_Document_Save__SWIG_4(lua_State* L) {
12223  int SWIG_arg = 0;
12225  Mezzanine::XML::Writer *arg2 = 0 ;
12226  Mezzanine::Char8 *arg3 = (Mezzanine::Char8 *) 0 ;
12227  unsigned int arg4 ;
12229 
12230  SWIG_check_num_args("Mezzanine::XML::Document::Save",5,5)
12231  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Document::Save",1,"Mezzanine::XML::Document const *");
12232  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Document::Save",2,"Mezzanine::XML::Writer &");
12233  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("Mezzanine::XML::Document::Save",3,"Mezzanine::Char8 const *");
12234  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::XML::Document::Save",4,"unsigned int");
12235  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::XML::Document::Save",5,"Mezzanine::XML::Encoding");
12236 
12237  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Document,0))){
12238  SWIG_fail_ptr("Document_Save",1,SWIGTYPE_p_Mezzanine__XML__Document);
12239  }
12240 
12241 
12242  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Writer,0))){
12243  SWIG_fail_ptr("Document_Save",2,SWIGTYPE_p_Mezzanine__XML__Writer);
12244  }
12245 
12246  arg3 = (Mezzanine::Char8 *)lua_tostring(L, 3);
12247  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
12248  arg4 = (unsigned int)lua_tonumber(L, 4);
12249  arg5 = (Mezzanine::XML::Encoding)(int)lua_tonumber(L, 5);
12250  ((Mezzanine::XML::Document const *)arg1)->Save(*arg2,(Mezzanine::Char8 const *)arg3,arg4,arg5);
12251 
12252  return SWIG_arg;
12253 
12254  if(0) SWIG_fail;
12255 
12256 fail:
12257  lua_error(L);
12258  return SWIG_arg;
12259 }
12260 
12261 
12262 static int _wrap_Document_Save__SWIG_5(lua_State* L) {
12263  int SWIG_arg = 0;
12265  Mezzanine::XML::Writer *arg2 = 0 ;
12266  Mezzanine::Char8 *arg3 = (Mezzanine::Char8 *) 0 ;
12267  unsigned int arg4 ;
12268 
12269  SWIG_check_num_args("Mezzanine::XML::Document::Save",4,4)
12270  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Document::Save",1,"Mezzanine::XML::Document const *");
12271  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Document::Save",2,"Mezzanine::XML::Writer &");
12272  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("Mezzanine::XML::Document::Save",3,"Mezzanine::Char8 const *");
12273  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::XML::Document::Save",4,"unsigned int");
12274 
12275  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Document,0))){
12276  SWIG_fail_ptr("Document_Save",1,SWIGTYPE_p_Mezzanine__XML__Document);
12277  }
12278 
12279 
12280  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Writer,0))){
12281  SWIG_fail_ptr("Document_Save",2,SWIGTYPE_p_Mezzanine__XML__Writer);
12282  }
12283 
12284  arg3 = (Mezzanine::Char8 *)lua_tostring(L, 3);
12285  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
12286  arg4 = (unsigned int)lua_tonumber(L, 4);
12287  ((Mezzanine::XML::Document const *)arg1)->Save(*arg2,(Mezzanine::Char8 const *)arg3,arg4);
12288 
12289  return SWIG_arg;
12290 
12291  if(0) SWIG_fail;
12292 
12293 fail:
12294  lua_error(L);
12295  return SWIG_arg;
12296 }
12297 
12298 
12299 static int _wrap_Document_Save__SWIG_6(lua_State* L) {
12300  int SWIG_arg = 0;
12302  Mezzanine::XML::Writer *arg2 = 0 ;
12303  Mezzanine::Char8 *arg3 = (Mezzanine::Char8 *) 0 ;
12304 
12305  SWIG_check_num_args("Mezzanine::XML::Document::Save",3,3)
12306  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Document::Save",1,"Mezzanine::XML::Document const *");
12307  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Document::Save",2,"Mezzanine::XML::Writer &");
12308  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("Mezzanine::XML::Document::Save",3,"Mezzanine::Char8 const *");
12309 
12310  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Document,0))){
12311  SWIG_fail_ptr("Document_Save",1,SWIGTYPE_p_Mezzanine__XML__Document);
12312  }
12313 
12314 
12315  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Writer,0))){
12316  SWIG_fail_ptr("Document_Save",2,SWIGTYPE_p_Mezzanine__XML__Writer);
12317  }
12318 
12319  arg3 = (Mezzanine::Char8 *)lua_tostring(L, 3);
12320  ((Mezzanine::XML::Document const *)arg1)->Save(*arg2,(Mezzanine::Char8 const *)arg3);
12321 
12322  return SWIG_arg;
12323 
12324  if(0) SWIG_fail;
12325 
12326 fail:
12327  lua_error(L);
12328  return SWIG_arg;
12329 }
12330 
12331 
12332 static int _wrap_Document_Save__SWIG_7(lua_State* L) {
12333  int SWIG_arg = 0;
12335  Mezzanine::XML::Writer *arg2 = 0 ;
12336 
12337  SWIG_check_num_args("Mezzanine::XML::Document::Save",2,2)
12338  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Document::Save",1,"Mezzanine::XML::Document const *");
12339  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Document::Save",2,"Mezzanine::XML::Writer &");
12340 
12341  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Document,0))){
12342  SWIG_fail_ptr("Document_Save",1,SWIGTYPE_p_Mezzanine__XML__Document);
12343  }
12344 
12345 
12346  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Writer,0))){
12347  SWIG_fail_ptr("Document_Save",2,SWIGTYPE_p_Mezzanine__XML__Writer);
12348  }
12349 
12350  ((Mezzanine::XML::Document const *)arg1)->Save(*arg2);
12351 
12352  return SWIG_arg;
12353 
12354  if(0) SWIG_fail;
12355 
12356 fail:
12357  lua_error(L);
12358  return SWIG_arg;
12359 }
12360 
12361 
12362 static int _wrap_Document_Save__SWIG_8(lua_State* L) {
12363  int SWIG_arg = 0;
12365  std::basic_ostream< char,std::char_traits< char > > *arg2 = 0 ;
12366  Mezzanine::Char8 *arg3 = (Mezzanine::Char8 *) 0 ;
12367  unsigned int arg4 ;
12369 
12370  SWIG_check_num_args("Mezzanine::XML::Document::Save",5,5)
12371  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Document::Save",1,"Mezzanine::XML::Document const *");
12372  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Document::Save",2,"std::basic_ostream< char,std::char_traits< char > > &");
12373  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("Mezzanine::XML::Document::Save",3,"Mezzanine::Char8 const *");
12374  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::XML::Document::Save",4,"unsigned int");
12375  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::XML::Document::Save",5,"Mezzanine::XML::Encoding");
12376 
12377  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Document,0))){
12378  SWIG_fail_ptr("Document_Save",1,SWIGTYPE_p_Mezzanine__XML__Document);
12379  }
12380 
12381 
12382  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,0))){
12383  SWIG_fail_ptr("Document_Save",2,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t);
12384  }
12385 
12386  arg3 = (Mezzanine::Char8 *)lua_tostring(L, 3);
12387  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
12388  arg4 = (unsigned int)lua_tonumber(L, 4);
12389  arg5 = (Mezzanine::XML::Encoding)(int)lua_tonumber(L, 5);
12390  ((Mezzanine::XML::Document const *)arg1)->Save(*arg2,(Mezzanine::Char8 const *)arg3,arg4,arg5);
12391 
12392  return SWIG_arg;
12393 
12394  if(0) SWIG_fail;
12395 
12396 fail:
12397  lua_error(L);
12398  return SWIG_arg;
12399 }
12400 
12401 
12402 static int _wrap_Document_Save__SWIG_9(lua_State* L) {
12403  int SWIG_arg = 0;
12405  std::basic_ostream< char,std::char_traits< char > > *arg2 = 0 ;
12406  Mezzanine::Char8 *arg3 = (Mezzanine::Char8 *) 0 ;
12407  unsigned int arg4 ;
12408 
12409  SWIG_check_num_args("Mezzanine::XML::Document::Save",4,4)
12410  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Document::Save",1,"Mezzanine::XML::Document const *");
12411  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Document::Save",2,"std::basic_ostream< char,std::char_traits< char > > &");
12412  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("Mezzanine::XML::Document::Save",3,"Mezzanine::Char8 const *");
12413  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::XML::Document::Save",4,"unsigned int");
12414 
12415  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Document,0))){
12416  SWIG_fail_ptr("Document_Save",1,SWIGTYPE_p_Mezzanine__XML__Document);
12417  }
12418 
12419 
12420  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,0))){
12421  SWIG_fail_ptr("Document_Save",2,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t);
12422  }
12423 
12424  arg3 = (Mezzanine::Char8 *)lua_tostring(L, 3);
12425  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
12426  arg4 = (unsigned int)lua_tonumber(L, 4);
12427  ((Mezzanine::XML::Document const *)arg1)->Save(*arg2,(Mezzanine::Char8 const *)arg3,arg4);
12428 
12429  return SWIG_arg;
12430 
12431  if(0) SWIG_fail;
12432 
12433 fail:
12434  lua_error(L);
12435  return SWIG_arg;
12436 }
12437 
12438 
12439 static int _wrap_Document_Save__SWIG_10(lua_State* L) {
12440  int SWIG_arg = 0;
12442  std::basic_ostream< char,std::char_traits< char > > *arg2 = 0 ;
12443  Mezzanine::Char8 *arg3 = (Mezzanine::Char8 *) 0 ;
12444 
12445  SWIG_check_num_args("Mezzanine::XML::Document::Save",3,3)
12446  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Document::Save",1,"Mezzanine::XML::Document const *");
12447  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Document::Save",2,"std::basic_ostream< char,std::char_traits< char > > &");
12448  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("Mezzanine::XML::Document::Save",3,"Mezzanine::Char8 const *");
12449 
12450  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Document,0))){
12451  SWIG_fail_ptr("Document_Save",1,SWIGTYPE_p_Mezzanine__XML__Document);
12452  }
12453 
12454 
12455  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,0))){
12456  SWIG_fail_ptr("Document_Save",2,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t);
12457  }
12458 
12459  arg3 = (Mezzanine::Char8 *)lua_tostring(L, 3);
12460  ((Mezzanine::XML::Document const *)arg1)->Save(*arg2,(Mezzanine::Char8 const *)arg3);
12461 
12462  return SWIG_arg;
12463 
12464  if(0) SWIG_fail;
12465 
12466 fail:
12467  lua_error(L);
12468  return SWIG_arg;
12469 }
12470 
12471 
12472 static int _wrap_Document_Save__SWIG_11(lua_State* L) {
12473  int SWIG_arg = 0;
12475  std::basic_ostream< char,std::char_traits< char > > *arg2 = 0 ;
12476 
12477  SWIG_check_num_args("Mezzanine::XML::Document::Save",2,2)
12478  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Document::Save",1,"Mezzanine::XML::Document const *");
12479  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Document::Save",2,"std::basic_ostream< char,std::char_traits< char > > &");
12480 
12481  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Document,0))){
12482  SWIG_fail_ptr("Document_Save",1,SWIGTYPE_p_Mezzanine__XML__Document);
12483  }
12484 
12485 
12486  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,0))){
12487  SWIG_fail_ptr("Document_Save",2,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t);
12488  }
12489 
12490  ((Mezzanine::XML::Document const *)arg1)->Save(*arg2);
12491 
12492  return SWIG_arg;
12493 
12494  if(0) SWIG_fail;
12495 
12496 fail:
12497  lua_error(L);
12498  return SWIG_arg;
12499 }
12500 
12501 
12502 static int _wrap_Document_Save__SWIG_12(lua_State* L) {
12503  int SWIG_arg = 0;
12505  std::basic_ostream< wchar_t,std::char_traits< wchar_t > > *arg2 = 0 ;
12506  Mezzanine::Char8 *arg3 = (Mezzanine::Char8 *) 0 ;
12507  unsigned int arg4 ;
12508 
12509  SWIG_check_num_args("Mezzanine::XML::Document::Save",4,4)
12510  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Document::Save",1,"Mezzanine::XML::Document const *");
12511  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Document::Save",2,"std::basic_ostream< wchar_t,std::char_traits< wchar_t > > &");
12512  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("Mezzanine::XML::Document::Save",3,"Mezzanine::Char8 const *");
12513  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::XML::Document::Save",4,"unsigned int");
12514 
12515  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Document,0))){
12516  SWIG_fail_ptr("Document_Save",1,SWIGTYPE_p_Mezzanine__XML__Document);
12517  }
12518 
12519 
12520  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__basic_ostreamT_wchar_t_std__char_traitsT_wchar_t_t_t,0))){
12521  SWIG_fail_ptr("Document_Save",2,SWIGTYPE_p_std__basic_ostreamT_wchar_t_std__char_traitsT_wchar_t_t_t);
12522  }
12523 
12524  arg3 = (Mezzanine::Char8 *)lua_tostring(L, 3);
12525  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
12526  arg4 = (unsigned int)lua_tonumber(L, 4);
12527  ((Mezzanine::XML::Document const *)arg1)->Save(*arg2,(Mezzanine::Char8 const *)arg3,arg4);
12528 
12529  return SWIG_arg;
12530 
12531  if(0) SWIG_fail;
12532 
12533 fail:
12534  lua_error(L);
12535  return SWIG_arg;
12536 }
12537 
12538 
12539 static int _wrap_Document_Save__SWIG_13(lua_State* L) {
12540  int SWIG_arg = 0;
12542  std::basic_ostream< wchar_t,std::char_traits< wchar_t > > *arg2 = 0 ;
12543  Mezzanine::Char8 *arg3 = (Mezzanine::Char8 *) 0 ;
12544 
12545  SWIG_check_num_args("Mezzanine::XML::Document::Save",3,3)
12546  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Document::Save",1,"Mezzanine::XML::Document const *");
12547  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Document::Save",2,"std::basic_ostream< wchar_t,std::char_traits< wchar_t > > &");
12548  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("Mezzanine::XML::Document::Save",3,"Mezzanine::Char8 const *");
12549 
12550  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Document,0))){
12551  SWIG_fail_ptr("Document_Save",1,SWIGTYPE_p_Mezzanine__XML__Document);
12552  }
12553 
12554 
12555  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__basic_ostreamT_wchar_t_std__char_traitsT_wchar_t_t_t,0))){
12556  SWIG_fail_ptr("Document_Save",2,SWIGTYPE_p_std__basic_ostreamT_wchar_t_std__char_traitsT_wchar_t_t_t);
12557  }
12558 
12559  arg3 = (Mezzanine::Char8 *)lua_tostring(L, 3);
12560  ((Mezzanine::XML::Document const *)arg1)->Save(*arg2,(Mezzanine::Char8 const *)arg3);
12561 
12562  return SWIG_arg;
12563 
12564  if(0) SWIG_fail;
12565 
12566 fail:
12567  lua_error(L);
12568  return SWIG_arg;
12569 }
12570 
12571 
12572 static int _wrap_Document_Save__SWIG_14(lua_State* L) {
12573  int SWIG_arg = 0;
12575  std::basic_ostream< wchar_t,std::char_traits< wchar_t > > *arg2 = 0 ;
12576 
12577  SWIG_check_num_args("Mezzanine::XML::Document::Save",2,2)
12578  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Document::Save",1,"Mezzanine::XML::Document const *");
12579  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Document::Save",2,"std::basic_ostream< wchar_t,std::char_traits< wchar_t > > &");
12580 
12581  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Document,0))){
12582  SWIG_fail_ptr("Document_Save",1,SWIGTYPE_p_Mezzanine__XML__Document);
12583  }
12584 
12585 
12586  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__basic_ostreamT_wchar_t_std__char_traitsT_wchar_t_t_t,0))){
12587  SWIG_fail_ptr("Document_Save",2,SWIGTYPE_p_std__basic_ostreamT_wchar_t_std__char_traitsT_wchar_t_t_t);
12588  }
12589 
12590  ((Mezzanine::XML::Document const *)arg1)->Save(*arg2);
12591 
12592  return SWIG_arg;
12593 
12594  if(0) SWIG_fail;
12595 
12596 fail:
12597  lua_error(L);
12598  return SWIG_arg;
12599 }
12600 
12601 
12602 static int _wrap_Document_Save(lua_State* L) {
12603  int argc;
12604  int argv[6]={
12605  1,2,3,4,5,6
12606  };
12607 
12608  argc = lua_gettop(L);
12609  if (argc == 2) {
12610  int _v;
12611  {
12612  void *ptr;
12613  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Document, 0)) {
12614  _v = 0;
12615  } else {
12616  _v = 1;
12617  }
12618  }
12619  if (_v) {
12620  {
12621  void *ptr;
12622  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Resource__DataStream, 0)) {
12623  _v = 0;
12624  } else {
12625  _v = 1;
12626  }
12627  }
12628  if (_v) {
12629  return _wrap_Document_Save__SWIG_3(L);
12630  }
12631  }
12632  }
12633  if (argc == 2) {
12634  int _v;
12635  {
12636  void *ptr;
12637  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Document, 0)) {
12638  _v = 0;
12639  } else {
12640  _v = 1;
12641  }
12642  }
12643  if (_v) {
12644  {
12645  void *ptr;
12646  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Writer, 0)) {
12647  _v = 0;
12648  } else {
12649  _v = 1;
12650  }
12651  }
12652  if (_v) {
12653  return _wrap_Document_Save__SWIG_7(L);
12654  }
12655  }
12656  }
12657  if (argc == 2) {
12658  int _v;
12659  {
12660  void *ptr;
12661  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Document, 0)) {
12662  _v = 0;
12663  } else {
12664  _v = 1;
12665  }
12666  }
12667  if (_v) {
12668  {
12669  void *ptr;
12670  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0)) {
12671  _v = 0;
12672  } else {
12673  _v = 1;
12674  }
12675  }
12676  if (_v) {
12677  return _wrap_Document_Save__SWIG_11(L);
12678  }
12679  }
12680  }
12681  if (argc == 2) {
12682  int _v;
12683  {
12684  void *ptr;
12685  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Document, 0)) {
12686  _v = 0;
12687  } else {
12688  _v = 1;
12689  }
12690  }
12691  if (_v) {
12692  {
12693  void *ptr;
12694  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__basic_ostreamT_wchar_t_std__char_traitsT_wchar_t_t_t, 0)) {
12695  _v = 0;
12696  } else {
12697  _v = 1;
12698  }
12699  }
12700  if (_v) {
12701  return _wrap_Document_Save__SWIG_14(L);
12702  }
12703  }
12704  }
12705  if (argc == 3) {
12706  int _v;
12707  {
12708  void *ptr;
12709  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Document, 0)) {
12710  _v = 0;
12711  } else {
12712  _v = 1;
12713  }
12714  }
12715  if (_v) {
12716  {
12717  void *ptr;
12718  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0)) {
12719  _v = 0;
12720  } else {
12721  _v = 1;
12722  }
12723  }
12724  if (_v) {
12725  {
12726  _v = SWIG_lua_isnilstring(L,argv[2]);
12727  }
12728  if (_v) {
12729  return _wrap_Document_Save__SWIG_10(L);
12730  }
12731  }
12732  }
12733  }
12734  if (argc == 3) {
12735  int _v;
12736  {
12737  void *ptr;
12738  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Document, 0)) {
12739  _v = 0;
12740  } else {
12741  _v = 1;
12742  }
12743  }
12744  if (_v) {
12745  {
12746  void *ptr;
12747  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Writer, 0)) {
12748  _v = 0;
12749  } else {
12750  _v = 1;
12751  }
12752  }
12753  if (_v) {
12754  {
12755  _v = SWIG_lua_isnilstring(L,argv[2]);
12756  }
12757  if (_v) {
12758  return _wrap_Document_Save__SWIG_6(L);
12759  }
12760  }
12761  }
12762  }
12763  if (argc == 3) {
12764  int _v;
12765  {
12766  void *ptr;
12767  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Document, 0)) {
12768  _v = 0;
12769  } else {
12770  _v = 1;
12771  }
12772  }
12773  if (_v) {
12774  {
12775  void *ptr;
12776  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__basic_ostreamT_wchar_t_std__char_traitsT_wchar_t_t_t, 0)) {
12777  _v = 0;
12778  } else {
12779  _v = 1;
12780  }
12781  }
12782  if (_v) {
12783  {
12784  _v = SWIG_lua_isnilstring(L,argv[2]);
12785  }
12786  if (_v) {
12787  return _wrap_Document_Save__SWIG_13(L);
12788  }
12789  }
12790  }
12791  }
12792  if (argc == 3) {
12793  int _v;
12794  {
12795  void *ptr;
12796  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Document, 0)) {
12797  _v = 0;
12798  } else {
12799  _v = 1;
12800  }
12801  }
12802  if (_v) {
12803  {
12804  void *ptr;
12805  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Resource__DataStream, 0)) {
12806  _v = 0;
12807  } else {
12808  _v = 1;
12809  }
12810  }
12811  if (_v) {
12812  {
12813  _v = SWIG_lua_isnilstring(L,argv[2]);
12814  }
12815  if (_v) {
12816  return _wrap_Document_Save__SWIG_2(L);
12817  }
12818  }
12819  }
12820  }
12821  if (argc == 4) {
12822  int _v;
12823  {
12824  void *ptr;
12825  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Document, 0)) {
12826  _v = 0;
12827  } else {
12828  _v = 1;
12829  }
12830  }
12831  if (_v) {
12832  {
12833  void *ptr;
12834  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Writer, 0)) {
12835  _v = 0;
12836  } else {
12837  _v = 1;
12838  }
12839  }
12840  if (_v) {
12841  {
12842  _v = SWIG_lua_isnilstring(L,argv[2]);
12843  }
12844  if (_v) {
12845  {
12846  _v = lua_isnumber(L,argv[3]);
12847  }
12848  if (_v) {
12849  return _wrap_Document_Save__SWIG_5(L);
12850  }
12851  }
12852  }
12853  }
12854  }
12855  if (argc == 4) {
12856  int _v;
12857  {
12858  void *ptr;
12859  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Document, 0)) {
12860  _v = 0;
12861  } else {
12862  _v = 1;
12863  }
12864  }
12865  if (_v) {
12866  {
12867  void *ptr;
12868  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__basic_ostreamT_wchar_t_std__char_traitsT_wchar_t_t_t, 0)) {
12869  _v = 0;
12870  } else {
12871  _v = 1;
12872  }
12873  }
12874  if (_v) {
12875  {
12876  _v = SWIG_lua_isnilstring(L,argv[2]);
12877  }
12878  if (_v) {
12879  {
12880  _v = lua_isnumber(L,argv[3]);
12881  }
12882  if (_v) {
12883  return _wrap_Document_Save__SWIG_12(L);
12884  }
12885  }
12886  }
12887  }
12888  }
12889  if (argc == 4) {
12890  int _v;
12891  {
12892  void *ptr;
12893  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Document, 0)) {
12894  _v = 0;
12895  } else {
12896  _v = 1;
12897  }
12898  }
12899  if (_v) {
12900  {
12901  void *ptr;
12902  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0)) {
12903  _v = 0;
12904  } else {
12905  _v = 1;
12906  }
12907  }
12908  if (_v) {
12909  {
12910  _v = SWIG_lua_isnilstring(L,argv[2]);
12911  }
12912  if (_v) {
12913  {
12914  _v = lua_isnumber(L,argv[3]);
12915  }
12916  if (_v) {
12917  return _wrap_Document_Save__SWIG_9(L);
12918  }
12919  }
12920  }
12921  }
12922  }
12923  if (argc == 4) {
12924  int _v;
12925  {
12926  void *ptr;
12927  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Document, 0)) {
12928  _v = 0;
12929  } else {
12930  _v = 1;
12931  }
12932  }
12933  if (_v) {
12934  {
12935  void *ptr;
12936  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Resource__DataStream, 0)) {
12937  _v = 0;
12938  } else {
12939  _v = 1;
12940  }
12941  }
12942  if (_v) {
12943  {
12944  _v = SWIG_lua_isnilstring(L,argv[2]);
12945  }
12946  if (_v) {
12947  {
12948  _v = lua_isnumber(L,argv[3]);
12949  }
12950  if (_v) {
12951  return _wrap_Document_Save__SWIG_1(L);
12952  }
12953  }
12954  }
12955  }
12956  }
12957  if (argc == 5) {
12958  int _v;
12959  {
12960  void *ptr;
12961  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Document, 0)) {
12962  _v = 0;
12963  } else {
12964  _v = 1;
12965  }
12966  }
12967  if (_v) {
12968  {
12969  void *ptr;
12970  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Writer, 0)) {
12971  _v = 0;
12972  } else {
12973  _v = 1;
12974  }
12975  }
12976  if (_v) {
12977  {
12978  _v = SWIG_lua_isnilstring(L,argv[2]);
12979  }
12980  if (_v) {
12981  {
12982  _v = lua_isnumber(L,argv[3]);
12983  }
12984  if (_v) {
12985  {
12986  _v = lua_isnumber(L,argv[4]);
12987  }
12988  if (_v) {
12989  return _wrap_Document_Save__SWIG_4(L);
12990  }
12991  }
12992  }
12993  }
12994  }
12995  }
12996  if (argc == 5) {
12997  int _v;
12998  {
12999  void *ptr;
13000  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Document, 0)) {
13001  _v = 0;
13002  } else {
13003  _v = 1;
13004  }
13005  }
13006  if (_v) {
13007  {
13008  void *ptr;
13009  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Resource__DataStream, 0)) {
13010  _v = 0;
13011  } else {
13012  _v = 1;
13013  }
13014  }
13015  if (_v) {
13016  {
13017  _v = SWIG_lua_isnilstring(L,argv[2]);
13018  }
13019  if (_v) {
13020  {
13021  _v = lua_isnumber(L,argv[3]);
13022  }
13023  if (_v) {
13024  {
13025  _v = lua_isnumber(L,argv[4]);
13026  }
13027  if (_v) {
13028  return _wrap_Document_Save__SWIG_0(L);
13029  }
13030  }
13031  }
13032  }
13033  }
13034  }
13035  if (argc == 5) {
13036  int _v;
13037  {
13038  void *ptr;
13039  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Document, 0)) {
13040  _v = 0;
13041  } else {
13042  _v = 1;
13043  }
13044  }
13045  if (_v) {
13046  {
13047  void *ptr;
13048  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0)) {
13049  _v = 0;
13050  } else {
13051  _v = 1;
13052  }
13053  }
13054  if (_v) {
13055  {
13056  _v = SWIG_lua_isnilstring(L,argv[2]);
13057  }
13058  if (_v) {
13059  {
13060  _v = lua_isnumber(L,argv[3]);
13061  }
13062  if (_v) {
13063  {
13064  _v = lua_isnumber(L,argv[4]);
13065  }
13066  if (_v) {
13067  return _wrap_Document_Save__SWIG_8(L);
13068  }
13069  }
13070  }
13071  }
13072  }
13073  }
13074 
13075  lua_pushstring(L,"Wrong arguments for overloaded function 'Document_Save'\n"
13076  " Possible C/C++ prototypes are:\n"
13077  " Mezzanine::XML::Document::Save(Resource::DataStream &,Mezzanine::Char8 const *,unsigned int,Mezzanine::XML::Encoding) const\n"
13078  " Mezzanine::XML::Document::Save(Resource::DataStream &,Mezzanine::Char8 const *,unsigned int) const\n"
13079  " Mezzanine::XML::Document::Save(Resource::DataStream &,Mezzanine::Char8 const *) const\n"
13080  " Mezzanine::XML::Document::Save(Resource::DataStream &) const\n"
13081  " Mezzanine::XML::Document::Save(Mezzanine::XML::Writer &,Mezzanine::Char8 const *,unsigned int,Mezzanine::XML::Encoding) const\n"
13082  " Mezzanine::XML::Document::Save(Mezzanine::XML::Writer &,Mezzanine::Char8 const *,unsigned int) const\n"
13083  " Mezzanine::XML::Document::Save(Mezzanine::XML::Writer &,Mezzanine::Char8 const *) const\n"
13084  " Mezzanine::XML::Document::Save(Mezzanine::XML::Writer &) const\n"
13085  " Mezzanine::XML::Document::Save(std::basic_ostream< char,std::char_traits< char > > &,Mezzanine::Char8 const *,unsigned int,Mezzanine::XML::Encoding) const\n"
13086  " Mezzanine::XML::Document::Save(std::basic_ostream< char,std::char_traits< char > > &,Mezzanine::Char8 const *,unsigned int) const\n"
13087  " Mezzanine::XML::Document::Save(std::basic_ostream< char,std::char_traits< char > > &,Mezzanine::Char8 const *) const\n"
13088  " Mezzanine::XML::Document::Save(std::basic_ostream< char,std::char_traits< char > > &) const\n"
13089  " Mezzanine::XML::Document::Save(std::basic_ostream< wchar_t,std::char_traits< wchar_t > > &,Mezzanine::Char8 const *,unsigned int) const\n"
13090  " Mezzanine::XML::Document::Save(std::basic_ostream< wchar_t,std::char_traits< wchar_t > > &,Mezzanine::Char8 const *) const\n"
13091  " Mezzanine::XML::Document::Save(std::basic_ostream< wchar_t,std::char_traits< wchar_t > > &) const\n");
13092  lua_error(L);return 0;
13093 }
13094 
13095 
13096 static int _wrap_Document_SaveFile__SWIG_0(lua_State* L) {
13097  int SWIG_arg = 0;
13099  char *arg2 = (char *) 0 ;
13100  Mezzanine::Char8 *arg3 = (Mezzanine::Char8 *) 0 ;
13101  unsigned int arg4 ;
13103  bool result;
13104 
13105  SWIG_check_num_args("Mezzanine::XML::Document::SaveFile",5,5)
13106  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Document::SaveFile",1,"Mezzanine::XML::Document const *");
13107  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Document::SaveFile",2,"char const *");
13108  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("Mezzanine::XML::Document::SaveFile",3,"Mezzanine::Char8 const *");
13109  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::XML::Document::SaveFile",4,"unsigned int");
13110  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::XML::Document::SaveFile",5,"Mezzanine::XML::Encoding");
13111 
13112  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Document,0))){
13113  SWIG_fail_ptr("Document_SaveFile",1,SWIGTYPE_p_Mezzanine__XML__Document);
13114  }
13115 
13116  arg2 = (char *)lua_tostring(L, 2);
13117  arg3 = (Mezzanine::Char8 *)lua_tostring(L, 3);
13118  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
13119  arg4 = (unsigned int)lua_tonumber(L, 4);
13120  arg5 = (Mezzanine::XML::Encoding)(int)lua_tonumber(L, 5);
13121  result = (bool)((Mezzanine::XML::Document const *)arg1)->SaveFile((char const *)arg2,(Mezzanine::Char8 const *)arg3,arg4,arg5);
13122  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
13123  return SWIG_arg;
13124 
13125  if(0) SWIG_fail;
13126 
13127 fail:
13128  lua_error(L);
13129  return SWIG_arg;
13130 }
13131 
13132 
13133 static int _wrap_Document_SaveFile__SWIG_1(lua_State* L) {
13134  int SWIG_arg = 0;
13136  char *arg2 = (char *) 0 ;
13137  Mezzanine::Char8 *arg3 = (Mezzanine::Char8 *) 0 ;
13138  unsigned int arg4 ;
13139  bool result;
13140 
13141  SWIG_check_num_args("Mezzanine::XML::Document::SaveFile",4,4)
13142  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Document::SaveFile",1,"Mezzanine::XML::Document const *");
13143  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Document::SaveFile",2,"char const *");
13144  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("Mezzanine::XML::Document::SaveFile",3,"Mezzanine::Char8 const *");
13145  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::XML::Document::SaveFile",4,"unsigned int");
13146 
13147  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Document,0))){
13148  SWIG_fail_ptr("Document_SaveFile",1,SWIGTYPE_p_Mezzanine__XML__Document);
13149  }
13150 
13151  arg2 = (char *)lua_tostring(L, 2);
13152  arg3 = (Mezzanine::Char8 *)lua_tostring(L, 3);
13153  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
13154  arg4 = (unsigned int)lua_tonumber(L, 4);
13155  result = (bool)((Mezzanine::XML::Document const *)arg1)->SaveFile((char const *)arg2,(Mezzanine::Char8 const *)arg3,arg4);
13156  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
13157  return SWIG_arg;
13158 
13159  if(0) SWIG_fail;
13160 
13161 fail:
13162  lua_error(L);
13163  return SWIG_arg;
13164 }
13165 
13166 
13167 static int _wrap_Document_SaveFile__SWIG_2(lua_State* L) {
13168  int SWIG_arg = 0;
13170  char *arg2 = (char *) 0 ;
13171  Mezzanine::Char8 *arg3 = (Mezzanine::Char8 *) 0 ;
13172  bool result;
13173 
13174  SWIG_check_num_args("Mezzanine::XML::Document::SaveFile",3,3)
13175  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Document::SaveFile",1,"Mezzanine::XML::Document const *");
13176  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Document::SaveFile",2,"char const *");
13177  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("Mezzanine::XML::Document::SaveFile",3,"Mezzanine::Char8 const *");
13178 
13179  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Document,0))){
13180  SWIG_fail_ptr("Document_SaveFile",1,SWIGTYPE_p_Mezzanine__XML__Document);
13181  }
13182 
13183  arg2 = (char *)lua_tostring(L, 2);
13184  arg3 = (Mezzanine::Char8 *)lua_tostring(L, 3);
13185  result = (bool)((Mezzanine::XML::Document const *)arg1)->SaveFile((char const *)arg2,(Mezzanine::Char8 const *)arg3);
13186  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
13187  return SWIG_arg;
13188 
13189  if(0) SWIG_fail;
13190 
13191 fail:
13192  lua_error(L);
13193  return SWIG_arg;
13194 }
13195 
13196 
13197 static int _wrap_Document_SaveFile__SWIG_3(lua_State* L) {
13198  int SWIG_arg = 0;
13200  char *arg2 = (char *) 0 ;
13201  bool result;
13202 
13203  SWIG_check_num_args("Mezzanine::XML::Document::SaveFile",2,2)
13204  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Document::SaveFile",1,"Mezzanine::XML::Document const *");
13205  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Document::SaveFile",2,"char const *");
13206 
13207  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Document,0))){
13208  SWIG_fail_ptr("Document_SaveFile",1,SWIGTYPE_p_Mezzanine__XML__Document);
13209  }
13210 
13211  arg2 = (char *)lua_tostring(L, 2);
13212  result = (bool)((Mezzanine::XML::Document const *)arg1)->SaveFile((char const *)arg2);
13213  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
13214  return SWIG_arg;
13215 
13216  if(0) SWIG_fail;
13217 
13218 fail:
13219  lua_error(L);
13220  return SWIG_arg;
13221 }
13222 
13223 
13224 static int _wrap_Document_SaveFile__SWIG_4(lua_State* L) {
13225  int SWIG_arg = 0;
13227  wchar_t *arg2 = (wchar_t *) 0 ;
13228  Mezzanine::Char8 *arg3 = (Mezzanine::Char8 *) 0 ;
13229  unsigned int arg4 ;
13231  bool result;
13232 
13233  SWIG_check_num_args("Mezzanine::XML::Document::SaveFile",5,5)
13234  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Document::SaveFile",1,"Mezzanine::XML::Document const *");
13235  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::XML::Document::SaveFile",2,"wchar_t const *");
13236  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("Mezzanine::XML::Document::SaveFile",3,"Mezzanine::Char8 const *");
13237  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::XML::Document::SaveFile",4,"unsigned int");
13238  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::XML::Document::SaveFile",5,"Mezzanine::XML::Encoding");
13239 
13240  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Document,0))){
13241  SWIG_fail_ptr("Document_SaveFile",1,SWIGTYPE_p_Mezzanine__XML__Document);
13242  }
13243 
13244 
13245  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_wchar_t,0))){
13246  SWIG_fail_ptr("Document_SaveFile",2,SWIGTYPE_p_wchar_t);
13247  }
13248 
13249  arg3 = (Mezzanine::Char8 *)lua_tostring(L, 3);
13250  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
13251  arg4 = (unsigned int)lua_tonumber(L, 4);
13252  arg5 = (Mezzanine::XML::Encoding)(int)lua_tonumber(L, 5);
13253  result = (bool)((Mezzanine::XML::Document const *)arg1)->SaveFile((wchar_t const *)arg2,(Mezzanine::Char8 const *)arg3,arg4,arg5);
13254  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
13255  return SWIG_arg;
13256 
13257  if(0) SWIG_fail;
13258 
13259 fail:
13260  lua_error(L);
13261  return SWIG_arg;
13262 }
13263 
13264 
13265 static int _wrap_Document_SaveFile__SWIG_5(lua_State* L) {
13266  int SWIG_arg = 0;
13268  wchar_t *arg2 = (wchar_t *) 0 ;
13269  Mezzanine::Char8 *arg3 = (Mezzanine::Char8 *) 0 ;
13270  unsigned int arg4 ;
13271  bool result;
13272 
13273  SWIG_check_num_args("Mezzanine::XML::Document::SaveFile",4,4)
13274  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Document::SaveFile",1,"Mezzanine::XML::Document const *");
13275  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::XML::Document::SaveFile",2,"wchar_t const *");
13276  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("Mezzanine::XML::Document::SaveFile",3,"Mezzanine::Char8 const *");
13277  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::XML::Document::SaveFile",4,"unsigned int");
13278 
13279  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Document,0))){
13280  SWIG_fail_ptr("Document_SaveFile",1,SWIGTYPE_p_Mezzanine__XML__Document);
13281  }
13282 
13283 
13284  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_wchar_t,0))){
13285  SWIG_fail_ptr("Document_SaveFile",2,SWIGTYPE_p_wchar_t);
13286  }
13287 
13288  arg3 = (Mezzanine::Char8 *)lua_tostring(L, 3);
13289  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
13290  arg4 = (unsigned int)lua_tonumber(L, 4);
13291  result = (bool)((Mezzanine::XML::Document const *)arg1)->SaveFile((wchar_t const *)arg2,(Mezzanine::Char8 const *)arg3,arg4);
13292  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
13293  return SWIG_arg;
13294 
13295  if(0) SWIG_fail;
13296 
13297 fail:
13298  lua_error(L);
13299  return SWIG_arg;
13300 }
13301 
13302 
13303 static int _wrap_Document_SaveFile__SWIG_6(lua_State* L) {
13304  int SWIG_arg = 0;
13306  wchar_t *arg2 = (wchar_t *) 0 ;
13307  Mezzanine::Char8 *arg3 = (Mezzanine::Char8 *) 0 ;
13308  bool result;
13309 
13310  SWIG_check_num_args("Mezzanine::XML::Document::SaveFile",3,3)
13311  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Document::SaveFile",1,"Mezzanine::XML::Document const *");
13312  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::XML::Document::SaveFile",2,"wchar_t const *");
13313  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("Mezzanine::XML::Document::SaveFile",3,"Mezzanine::Char8 const *");
13314 
13315  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Document,0))){
13316  SWIG_fail_ptr("Document_SaveFile",1,SWIGTYPE_p_Mezzanine__XML__Document);
13317  }
13318 
13319 
13320  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_wchar_t,0))){
13321  SWIG_fail_ptr("Document_SaveFile",2,SWIGTYPE_p_wchar_t);
13322  }
13323 
13324  arg3 = (Mezzanine::Char8 *)lua_tostring(L, 3);
13325  result = (bool)((Mezzanine::XML::Document const *)arg1)->SaveFile((wchar_t const *)arg2,(Mezzanine::Char8 const *)arg3);
13326  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
13327  return SWIG_arg;
13328 
13329  if(0) SWIG_fail;
13330 
13331 fail:
13332  lua_error(L);
13333  return SWIG_arg;
13334 }
13335 
13336 
13337 static int _wrap_Document_SaveFile__SWIG_7(lua_State* L) {
13338  int SWIG_arg = 0;
13340  wchar_t *arg2 = (wchar_t *) 0 ;
13341  bool result;
13342 
13343  SWIG_check_num_args("Mezzanine::XML::Document::SaveFile",2,2)
13344  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Document::SaveFile",1,"Mezzanine::XML::Document const *");
13345  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::XML::Document::SaveFile",2,"wchar_t const *");
13346 
13347  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Document,0))){
13348  SWIG_fail_ptr("Document_SaveFile",1,SWIGTYPE_p_Mezzanine__XML__Document);
13349  }
13350 
13351 
13352  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_wchar_t,0))){
13353  SWIG_fail_ptr("Document_SaveFile",2,SWIGTYPE_p_wchar_t);
13354  }
13355 
13356  result = (bool)((Mezzanine::XML::Document const *)arg1)->SaveFile((wchar_t const *)arg2);
13357  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
13358  return SWIG_arg;
13359 
13360  if(0) SWIG_fail;
13361 
13362 fail:
13363  lua_error(L);
13364  return SWIG_arg;
13365 }
13366 
13367 
13368 static int _wrap_Document_SaveFile(lua_State* L) {
13369  int argc;
13370  int argv[6]={
13371  1,2,3,4,5,6
13372  };
13373 
13374  argc = lua_gettop(L);
13375  if (argc == 2) {
13376  int _v;
13377  {
13378  void *ptr;
13379  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Document, 0)) {
13380  _v = 0;
13381  } else {
13382  _v = 1;
13383  }
13384  }
13385  if (_v) {
13386  {
13387  void *ptr;
13388  if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_wchar_t, 0)) {
13389  _v = 0;
13390  } else {
13391  _v = 1;
13392  }
13393  }
13394  if (_v) {
13395  return _wrap_Document_SaveFile__SWIG_7(L);
13396  }
13397  }
13398  }
13399  if (argc == 2) {
13400  int _v;
13401  {
13402  void *ptr;
13403  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Document, 0)) {
13404  _v = 0;
13405  } else {
13406  _v = 1;
13407  }
13408  }
13409  if (_v) {
13410  {
13411  _v = SWIG_lua_isnilstring(L,argv[1]);
13412  }
13413  if (_v) {
13414  return _wrap_Document_SaveFile__SWIG_3(L);
13415  }
13416  }
13417  }
13418  if (argc == 3) {
13419  int _v;
13420  {
13421  void *ptr;
13422  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Document, 0)) {
13423  _v = 0;
13424  } else {
13425  _v = 1;
13426  }
13427  }
13428  if (_v) {
13429  {
13430  void *ptr;
13431  if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_wchar_t, 0)) {
13432  _v = 0;
13433  } else {
13434  _v = 1;
13435  }
13436  }
13437  if (_v) {
13438  {
13439  _v = SWIG_lua_isnilstring(L,argv[2]);
13440  }
13441  if (_v) {
13442  return _wrap_Document_SaveFile__SWIG_6(L);
13443  }
13444  }
13445  }
13446  }
13447  if (argc == 3) {
13448  int _v;
13449  {
13450  void *ptr;
13451  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Document, 0)) {
13452  _v = 0;
13453  } else {
13454  _v = 1;
13455  }
13456  }
13457  if (_v) {
13458  {
13459  _v = SWIG_lua_isnilstring(L,argv[1]);
13460  }
13461  if (_v) {
13462  {
13463  _v = SWIG_lua_isnilstring(L,argv[2]);
13464  }
13465  if (_v) {
13466  return _wrap_Document_SaveFile__SWIG_2(L);
13467  }
13468  }
13469  }
13470  }
13471  if (argc == 4) {
13472  int _v;
13473  {
13474  void *ptr;
13475  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Document, 0)) {
13476  _v = 0;
13477  } else {
13478  _v = 1;
13479  }
13480  }
13481  if (_v) {
13482  {
13483  void *ptr;
13484  if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_wchar_t, 0)) {
13485  _v = 0;
13486  } else {
13487  _v = 1;
13488  }
13489  }
13490  if (_v) {
13491  {
13492  _v = SWIG_lua_isnilstring(L,argv[2]);
13493  }
13494  if (_v) {
13495  {
13496  _v = lua_isnumber(L,argv[3]);
13497  }
13498  if (_v) {
13499  return _wrap_Document_SaveFile__SWIG_5(L);
13500  }
13501  }
13502  }
13503  }
13504  }
13505  if (argc == 4) {
13506  int _v;
13507  {
13508  void *ptr;
13509  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Document, 0)) {
13510  _v = 0;
13511  } else {
13512  _v = 1;
13513  }
13514  }
13515  if (_v) {
13516  {
13517  _v = SWIG_lua_isnilstring(L,argv[1]);
13518  }
13519  if (_v) {
13520  {
13521  _v = SWIG_lua_isnilstring(L,argv[2]);
13522  }
13523  if (_v) {
13524  {
13525  _v = lua_isnumber(L,argv[3]);
13526  }
13527  if (_v) {
13528  return _wrap_Document_SaveFile__SWIG_1(L);
13529  }
13530  }
13531  }
13532  }
13533  }
13534  if (argc == 5) {
13535  int _v;
13536  {
13537  void *ptr;
13538  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Document, 0)) {
13539  _v = 0;
13540  } else {
13541  _v = 1;
13542  }
13543  }
13544  if (_v) {
13545  {
13546  void *ptr;
13547  if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_wchar_t, 0)) {
13548  _v = 0;
13549  } else {
13550  _v = 1;
13551  }
13552  }
13553  if (_v) {
13554  {
13555  _v = SWIG_lua_isnilstring(L,argv[2]);
13556  }
13557  if (_v) {
13558  {
13559  _v = lua_isnumber(L,argv[3]);
13560  }
13561  if (_v) {
13562  {
13563  _v = lua_isnumber(L,argv[4]);
13564  }
13565  if (_v) {
13566  return _wrap_Document_SaveFile__SWIG_4(L);
13567  }
13568  }
13569  }
13570  }
13571  }
13572  }
13573  if (argc == 5) {
13574  int _v;
13575  {
13576  void *ptr;
13577  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Document, 0)) {
13578  _v = 0;
13579  } else {
13580  _v = 1;
13581  }
13582  }
13583  if (_v) {
13584  {
13585  _v = SWIG_lua_isnilstring(L,argv[1]);
13586  }
13587  if (_v) {
13588  {
13589  _v = SWIG_lua_isnilstring(L,argv[2]);
13590  }
13591  if (_v) {
13592  {
13593  _v = lua_isnumber(L,argv[3]);
13594  }
13595  if (_v) {
13596  {
13597  _v = lua_isnumber(L,argv[4]);
13598  }
13599  if (_v) {
13600  return _wrap_Document_SaveFile__SWIG_0(L);
13601  }
13602  }
13603  }
13604  }
13605  }
13606  }
13607 
13608  lua_pushstring(L,"Wrong arguments for overloaded function 'Document_SaveFile'\n"
13609  " Possible C/C++ prototypes are:\n"
13610  " Mezzanine::XML::Document::SaveFile(char const *,Mezzanine::Char8 const *,unsigned int,Mezzanine::XML::Encoding) const\n"
13611  " Mezzanine::XML::Document::SaveFile(char const *,Mezzanine::Char8 const *,unsigned int) const\n"
13612  " Mezzanine::XML::Document::SaveFile(char const *,Mezzanine::Char8 const *) const\n"
13613  " Mezzanine::XML::Document::SaveFile(char const *) const\n"
13614  " Mezzanine::XML::Document::SaveFile(wchar_t const *,Mezzanine::Char8 const *,unsigned int,Mezzanine::XML::Encoding) const\n"
13615  " Mezzanine::XML::Document::SaveFile(wchar_t const *,Mezzanine::Char8 const *,unsigned int) const\n"
13616  " Mezzanine::XML::Document::SaveFile(wchar_t const *,Mezzanine::Char8 const *) const\n"
13617  " Mezzanine::XML::Document::SaveFile(wchar_t const *) const\n");
13618  lua_error(L);return 0;
13619 }
13620 
13621 
13622 static int _wrap_Document_DocumentElement(lua_State* L) {
13623  int SWIG_arg = 0;
13625  Mezzanine::XML::Node result;
13626 
13627  SWIG_check_num_args("Mezzanine::XML::Document::DocumentElement",1,1)
13628  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Document::DocumentElement",1,"Mezzanine::XML::Document const *");
13629 
13630  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Document,0))){
13631  SWIG_fail_ptr("Document_DocumentElement",1,SWIGTYPE_p_Mezzanine__XML__Document);
13632  }
13633 
13634  result = ((Mezzanine::XML::Document const *)arg1)->DocumentElement();
13635  {
13636  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
13637  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
13638  }
13639  return SWIG_arg;
13640 
13641  if(0) SWIG_fail;
13642 
13643 fail:
13644  lua_error(L);
13645  return SWIG_arg;
13646 }
13647 
13648 
13649 static void swig_delete_Document(void *obj) {
13651 delete arg1;
13652 }
13653 static swig_lua_method swig_Mezzanine_XML_Document_methods[] = {
13654  {"Reset", _wrap_Document_Reset},
13655  {"Load", _wrap_Document_Load},
13656  {"LoadFile", _wrap_Document_LoadFile},
13657  {"LoadBuffer", _wrap_Document_LoadBuffer},
13658  {"LoadBufferInplace", _wrap_Document_LoadBufferInplace},
13659  {"LoadBufferInplaceOwn", _wrap_Document_LoadBufferInplaceOwn},
13660  {"Save", _wrap_Document_Save},
13661  {"SaveFile", _wrap_Document_SaveFile},
13662  {"DocumentElement", _wrap_Document_DocumentElement},
13663  {0,0}
13664 };
13665 static swig_lua_attribute swig_Mezzanine_XML_Document_attributes[] = {
13666  {0,0,0}
13667 };
13668 static swig_lua_class *swig_Mezzanine_XML_Document_bases[] = {0,0};
13669 static const char *swig_Mezzanine_XML_Document_base_names[] = {"Mezzanine::XML::Node *",0};
13670 static swig_lua_class _wrap_class_Mezzanine_XML_Document = { "Document", &SWIGTYPE_p_Mezzanine__XML__Document,_wrap_new_Document, swig_delete_Document, swig_Mezzanine_XML_Document_methods, swig_Mezzanine_XML_Document_attributes, swig_Mezzanine_XML_Document_bases, swig_Mezzanine_XML_Document_base_names };
13671 
13672 static int _wrap_SetMemoryManagementFunctions(lua_State* L) {
13673  int SWIG_arg = 0;
13676 
13677  SWIG_check_num_args("Mezzanine::XML::SetMemoryManagementFunctions",2,2)
13678  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::SetMemoryManagementFunctions",1,"Mezzanine::XML::AllocationFunction");
13679  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::XML::SetMemoryManagementFunctions",2,"Mezzanine::XML::DeAllocationFunction");
13680 
13681  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_f_size_t__p_void,0))){
13682  SWIG_fail_ptr("SetMemoryManagementFunctions",1,SWIGTYPE_p_f_size_t__p_void);
13683  }
13684 
13685 
13686  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_f_p_void__void,0))){
13687  SWIG_fail_ptr("SetMemoryManagementFunctions",2,SWIGTYPE_p_f_p_void__void);
13688  }
13689 
13691 
13692  return SWIG_arg;
13693 
13694  if(0) SWIG_fail;
13695 
13696 fail:
13697  lua_error(L);
13698  return SWIG_arg;
13699 }
13700 
13701 
13702 static int _wrap_GetMemoryAllocationFunction(lua_State* L) {
13703  int SWIG_arg = 0;
13705 
13706  SWIG_check_num_args("Mezzanine::XML::GetMemoryAllocationFunction",0,0)
13707  result = (Mezzanine::XML::AllocationFunction)Mezzanine::XML::GetMemoryAllocationFunction();
13708  SWIG_NewPointerObj(L,result,SWIGTYPE_p_f_size_t__p_void,0); SWIG_arg++;
13709  return SWIG_arg;
13710 
13711  if(0) SWIG_fail;
13712 
13713 fail:
13714  lua_error(L);
13715  return SWIG_arg;
13716 }
13717 
13718 
13719 static int _wrap_GetMemoryDeallocationFunction(lua_State* L) {
13720  int SWIG_arg = 0;
13722 
13723  SWIG_check_num_args("Mezzanine::XML::GetMemoryDeallocationFunction",0,0)
13724  result = (Mezzanine::XML::DeAllocationFunction)Mezzanine::XML::GetMemoryDeallocationFunction();
13725  SWIG_NewPointerObj(L,result,SWIGTYPE_p_f_p_void__void,0); SWIG_arg++;
13726  return SWIG_arg;
13727 
13728  if(0) SWIG_fail;
13729 
13730 fail:
13731  lua_error(L);
13732  return SWIG_arg;
13733 }
13734 
13735 
13736 static int _wrap_new_NodeIterator__SWIG_0(lua_State* L) {
13737  int SWIG_arg = 0;
13738  Mezzanine::XML::NodeIterator *result = 0 ;
13739 
13740  SWIG_check_num_args("Mezzanine::XML::NodeIterator::NodeIterator",0,0)
13741  result = (Mezzanine::XML::NodeIterator *)new Mezzanine::XML::NodeIterator();
13742  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__XML__NodeIterator,1); SWIG_arg++;
13743  return SWIG_arg;
13744 
13745  if(0) SWIG_fail;
13746 
13747 fail:
13748  lua_error(L);
13749  return SWIG_arg;
13750 }
13751 
13752 
13753 static int _wrap_new_NodeIterator__SWIG_1(lua_State* L) {
13754  int SWIG_arg = 0;
13755  Mezzanine::XML::Node *arg1 = 0 ;
13756  Mezzanine::XML::NodeIterator *result = 0 ;
13757 
13758  SWIG_check_num_args("Mezzanine::XML::NodeIterator::NodeIterator",1,1)
13759  if(!lua_isuserdata(L,1)) SWIG_fail_arg("Mezzanine::XML::NodeIterator::NodeIterator",1,"Mezzanine::XML::Node const &");
13760 
13761  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
13762  SWIG_fail_ptr("new_NodeIterator",1,SWIGTYPE_p_Mezzanine__XML__Node);
13763  }
13764 
13766  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__XML__NodeIterator,1); SWIG_arg++;
13767  return SWIG_arg;
13768 
13769  if(0) SWIG_fail;
13770 
13771 fail:
13772  lua_error(L);
13773  return SWIG_arg;
13774 }
13775 
13776 
13777 static int _wrap_new_NodeIterator(lua_State* L) {
13778  int argc;
13779  int argv[2]={
13780  1,2
13781  };
13782 
13783  argc = lua_gettop(L);
13784  if (argc == 0) {
13785  return _wrap_new_NodeIterator__SWIG_0(L);
13786  }
13787  if (argc == 1) {
13788  int _v;
13789  {
13790  void *ptr;
13791  if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
13792  _v = 0;
13793  } else {
13794  _v = 1;
13795  }
13796  }
13797  if (_v) {
13798  return _wrap_new_NodeIterator__SWIG_1(L);
13799  }
13800  }
13801 
13802  lua_pushstring(L,"Wrong arguments for overloaded function 'new_NodeIterator'\n"
13803  " Possible C/C++ prototypes are:\n"
13804  " Mezzanine::XML::NodeIterator::NodeIterator()\n"
13805  " Mezzanine::XML::NodeIterator::NodeIterator(Mezzanine::XML::Node const &)\n");
13806  lua_error(L);return 0;
13807 }
13808 
13809 
13810 static int _wrap_NodeIterator___eq(lua_State* L) {
13811  int SWIG_arg = 0;
13813  Mezzanine::XML::NodeIterator *arg2 = 0 ;
13814  bool result;
13815 
13816  SWIG_check_num_args("Mezzanine::XML::NodeIterator::operator ==",2,2)
13817  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::NodeIterator::operator ==",1,"Mezzanine::XML::NodeIterator const *");
13818  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::NodeIterator::operator ==",2,"Mezzanine::XML::NodeIterator const &");
13819 
13820  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
13821  SWIG_fail_ptr("NodeIterator___eq",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
13822  }
13823 
13824 
13825  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
13826  SWIG_fail_ptr("NodeIterator___eq",2,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
13827  }
13828 
13829  result = (bool)((Mezzanine::XML::NodeIterator const *)arg1)->operator ==((Mezzanine::XML::NodeIterator const &)*arg2);
13830  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
13831  return SWIG_arg;
13832 
13833  if(0) SWIG_fail;
13834 
13835 fail:
13836  lua_error(L);
13837  return SWIG_arg;
13838 }
13839 
13840 
13841 static int _wrap_NodeIterator___ref__(lua_State* L) {
13842  int SWIG_arg = 0;
13844  Mezzanine::XML::Node *result = 0 ;
13845 
13846  SWIG_check_num_args("Mezzanine::XML::NodeIterator::operator *",1,1)
13847  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::NodeIterator::operator *",1,"Mezzanine::XML::NodeIterator const *");
13848 
13849  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
13850  SWIG_fail_ptr("NodeIterator___ref__",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
13851  }
13852 
13853  result = (Mezzanine::XML::Node *) &((Mezzanine::XML::NodeIterator const *)arg1)->operator *();
13854  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__XML__Node,0); SWIG_arg++;
13855  return SWIG_arg;
13856 
13857  if(0) SWIG_fail;
13858 
13859 fail:
13860  lua_error(L);
13861  return SWIG_arg;
13862 }
13863 
13864 
13865 static int _wrap_NodeIterator___deref__(lua_State* L) {
13866  int SWIG_arg = 0;
13868  Mezzanine::XML::Node *result = 0 ;
13869 
13870  SWIG_check_num_args("Mezzanine::XML::NodeIterator::operator ->",1,1)
13871  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::NodeIterator::operator ->",1,"Mezzanine::XML::NodeIterator const *");
13872 
13873  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
13874  SWIG_fail_ptr("NodeIterator___deref__",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
13875  }
13876 
13877  result = (Mezzanine::XML::Node *)((Mezzanine::XML::NodeIterator const *)arg1)->operator ->();
13878  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__XML__Node,0); SWIG_arg++;
13879  return SWIG_arg;
13880 
13881  if(0) SWIG_fail;
13882 
13883 fail:
13884  lua_error(L);
13885  return SWIG_arg;
13886 }
13887 
13888 
13889 static int _wrap_NodeIterator___lt(lua_State* L) {
13890  int SWIG_arg = 0;
13892  Mezzanine::XML::Node *arg2 = 0 ;
13893  bool result;
13894 
13895  SWIG_check_num_args("Mezzanine::XML::Node::operator <",2,2)
13896  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::operator <",1,"Mezzanine::XML::NodeIterator const *");
13897  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::operator <",2,"Mezzanine::XML::Node const &");
13898 
13899  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
13900  SWIG_fail_ptr("NodeIterator___lt",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
13901  }
13902 
13903 
13904  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Node,0))){
13905  SWIG_fail_ptr("NodeIterator___lt",2,SWIGTYPE_p_Mezzanine__XML__Node);
13906  }
13907 
13908  result = (bool)(*arg1)->operator <((Mezzanine::XML::Node const &)*arg2);
13909  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
13910  return SWIG_arg;
13911 
13912  if(0) SWIG_fail;
13913 
13914 fail:
13915  lua_error(L);
13916  return SWIG_arg;
13917 }
13918 
13919 
13920 static int _wrap_NodeIterator___le(lua_State* L) {
13921  int SWIG_arg = 0;
13923  Mezzanine::XML::Node *arg2 = 0 ;
13924  bool result;
13925 
13926  SWIG_check_num_args("Mezzanine::XML::Node::operator <=",2,2)
13927  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::operator <=",1,"Mezzanine::XML::NodeIterator const *");
13928  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::operator <=",2,"Mezzanine::XML::Node const &");
13929 
13930  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
13931  SWIG_fail_ptr("NodeIterator___le",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
13932  }
13933 
13934 
13935  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Node,0))){
13936  SWIG_fail_ptr("NodeIterator___le",2,SWIGTYPE_p_Mezzanine__XML__Node);
13937  }
13938 
13939  result = (bool)(*arg1)->operator <=((Mezzanine::XML::Node const &)*arg2);
13940  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
13941  return SWIG_arg;
13942 
13943  if(0) SWIG_fail;
13944 
13945 fail:
13946  lua_error(L);
13947  return SWIG_arg;
13948 }
13949 
13950 
13951 static int _wrap_NodeIterator_Empty(lua_State* L) {
13952  int SWIG_arg = 0;
13954  bool result;
13955 
13956  SWIG_check_num_args("Mezzanine::XML::Node::Empty",1,1)
13957  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Empty",1,"Mezzanine::XML::NodeIterator const *");
13958 
13959  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
13960  SWIG_fail_ptr("NodeIterator_Empty",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
13961  }
13962 
13963  result = (bool)(*arg1)->Empty();
13964  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
13965  return SWIG_arg;
13966 
13967  if(0) SWIG_fail;
13968 
13969 fail:
13970  lua_error(L);
13971  return SWIG_arg;
13972 }
13973 
13974 
13975 static int _wrap_NodeIterator_Type(lua_State* L) {
13976  int SWIG_arg = 0;
13978  Mezzanine::XML::NodeType result;
13979 
13980  SWIG_check_num_args("Mezzanine::XML::Node::Type",1,1)
13981  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Type",1,"Mezzanine::XML::NodeIterator const *");
13982 
13983  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
13984  SWIG_fail_ptr("NodeIterator_Type",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
13985  }
13986 
13987  result = (Mezzanine::XML::NodeType)(*arg1)->Type();
13988  lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++;
13989  return SWIG_arg;
13990 
13991  if(0) SWIG_fail;
13992 
13993 fail:
13994  lua_error(L);
13995  return SWIG_arg;
13996 }
13997 
13998 
13999 static int _wrap_NodeIterator_Name(lua_State* L) {
14000  int SWIG_arg = 0;
14002  Mezzanine::Char8 *result = 0 ;
14003 
14004  SWIG_check_num_args("Mezzanine::XML::Node::Name",1,1)
14005  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Name",1,"Mezzanine::XML::NodeIterator const *");
14006 
14007  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
14008  SWIG_fail_ptr("NodeIterator_Name",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
14009  }
14010 
14011  result = (Mezzanine::Char8 *)(*arg1)->Name();
14012  lua_pushstring(L,(const char *)result); SWIG_arg++;
14013  return SWIG_arg;
14014 
14015  if(0) SWIG_fail;
14016 
14017 fail:
14018  lua_error(L);
14019  return SWIG_arg;
14020 }
14021 
14022 
14023 static int _wrap_NodeIterator_Value(lua_State* L) {
14024  int SWIG_arg = 0;
14026  Mezzanine::Char8 *result = 0 ;
14027 
14028  SWIG_check_num_args("Mezzanine::XML::Node::Value",1,1)
14029  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Value",1,"Mezzanine::XML::NodeIterator const *");
14030 
14031  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
14032  SWIG_fail_ptr("NodeIterator_Value",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
14033  }
14034 
14035  result = (Mezzanine::Char8 *)(*arg1)->Value();
14036  lua_pushstring(L,(const char *)result); SWIG_arg++;
14037  return SWIG_arg;
14038 
14039  if(0) SWIG_fail;
14040 
14041 fail:
14042  lua_error(L);
14043  return SWIG_arg;
14044 }
14045 
14046 
14047 static int _wrap_NodeIterator_GetFirstAttribute(lua_State* L) {
14048  int SWIG_arg = 0;
14051 
14052  SWIG_check_num_args("Mezzanine::XML::Node::GetFirstAttribute",1,1)
14053  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::GetFirstAttribute",1,"Mezzanine::XML::NodeIterator const *");
14054 
14055  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
14056  SWIG_fail_ptr("NodeIterator_GetFirstAttribute",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
14057  }
14058 
14059  result = (*arg1)->GetFirstAttribute();
14060  {
14062  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Attribute,1); SWIG_arg++;
14063  }
14064  return SWIG_arg;
14065 
14066  if(0) SWIG_fail;
14067 
14068 fail:
14069  lua_error(L);
14070  return SWIG_arg;
14071 }
14072 
14073 
14074 static int _wrap_NodeIterator_GetLastAttribute(lua_State* L) {
14075  int SWIG_arg = 0;
14078 
14079  SWIG_check_num_args("Mezzanine::XML::Node::GetLastAttribute",1,1)
14080  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::GetLastAttribute",1,"Mezzanine::XML::NodeIterator const *");
14081 
14082  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
14083  SWIG_fail_ptr("NodeIterator_GetLastAttribute",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
14084  }
14085 
14086  result = (*arg1)->GetLastAttribute();
14087  {
14089  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Attribute,1); SWIG_arg++;
14090  }
14091  return SWIG_arg;
14092 
14093  if(0) SWIG_fail;
14094 
14095 fail:
14096  lua_error(L);
14097  return SWIG_arg;
14098 }
14099 
14100 
14101 static int _wrap_NodeIterator_GetFirstChild(lua_State* L) {
14102  int SWIG_arg = 0;
14104  Mezzanine::XML::Node result;
14105 
14106  SWIG_check_num_args("Mezzanine::XML::Node::GetFirstChild",1,1)
14107  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::GetFirstChild",1,"Mezzanine::XML::NodeIterator const *");
14108 
14109  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
14110  SWIG_fail_ptr("NodeIterator_GetFirstChild",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
14111  }
14112 
14113  result = (*arg1)->GetFirstChild();
14114  {
14115  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
14116  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
14117  }
14118  return SWIG_arg;
14119 
14120  if(0) SWIG_fail;
14121 
14122 fail:
14123  lua_error(L);
14124  return SWIG_arg;
14125 }
14126 
14127 
14128 static int _wrap_NodeIterator_GetLastChild(lua_State* L) {
14129  int SWIG_arg = 0;
14131  Mezzanine::XML::Node result;
14132 
14133  SWIG_check_num_args("Mezzanine::XML::Node::GetLastChild",1,1)
14134  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::GetLastChild",1,"Mezzanine::XML::NodeIterator const *");
14135 
14136  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
14137  SWIG_fail_ptr("NodeIterator_GetLastChild",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
14138  }
14139 
14140  result = (*arg1)->GetLastChild();
14141  {
14142  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
14143  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
14144  }
14145  return SWIG_arg;
14146 
14147  if(0) SWIG_fail;
14148 
14149 fail:
14150  lua_error(L);
14151  return SWIG_arg;
14152 }
14153 
14154 
14155 static int _wrap_NodeIterator_GetNextSibling__SWIG_0(lua_State* L) {
14156  int SWIG_arg = 0;
14158  Mezzanine::XML::Node result;
14159 
14160  SWIG_check_num_args("Mezzanine::XML::Node::GetNextSibling",1,1)
14161  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::GetNextSibling",1,"Mezzanine::XML::NodeIterator const *");
14162 
14163  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
14164  SWIG_fail_ptr("NodeIterator_GetNextSibling",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
14165  }
14166 
14167  result = (*arg1)->GetNextSibling();
14168  {
14169  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
14170  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
14171  }
14172  return SWIG_arg;
14173 
14174  if(0) SWIG_fail;
14175 
14176 fail:
14177  lua_error(L);
14178  return SWIG_arg;
14179 }
14180 
14181 
14182 static int _wrap_NodeIterator_GetNextSibling__SWIG_1(lua_State* L) {
14183  int SWIG_arg = 0;
14185  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
14186  Mezzanine::XML::Node result;
14187 
14188  SWIG_check_num_args("Mezzanine::XML::Node::GetNextSibling",2,2)
14189  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::GetNextSibling",1,"Mezzanine::XML::NodeIterator const *");
14190  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::GetNextSibling",2,"Mezzanine::Char8 const *");
14191 
14192  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
14193  SWIG_fail_ptr("NodeIterator_GetNextSibling",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
14194  }
14195 
14196  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
14197  result = (*arg1)->GetNextSibling((Mezzanine::Char8 const *)arg2);
14198  {
14199  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
14200  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
14201  }
14202  return SWIG_arg;
14203 
14204  if(0) SWIG_fail;
14205 
14206 fail:
14207  lua_error(L);
14208  return SWIG_arg;
14209 }
14210 
14211 
14212 static int _wrap_NodeIterator_GetNextSibling(lua_State* L) {
14213  int argc;
14214  int argv[3]={
14215  1,2,3
14216  };
14217 
14218  argc = lua_gettop(L);
14219  if (argc == 1) {
14220  int _v;
14221  {
14222  void *ptr;
14223  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeIterator, 0)) {
14224  _v = 0;
14225  } else {
14226  _v = 1;
14227  }
14228  }
14229  if (_v) {
14230  return _wrap_NodeIterator_GetNextSibling__SWIG_0(L);
14231  }
14232  }
14233  if (argc == 2) {
14234  int _v;
14235  {
14236  void *ptr;
14237  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeIterator, 0)) {
14238  _v = 0;
14239  } else {
14240  _v = 1;
14241  }
14242  }
14243  if (_v) {
14244  {
14245  _v = SWIG_lua_isnilstring(L,argv[1]);
14246  }
14247  if (_v) {
14248  return _wrap_NodeIterator_GetNextSibling__SWIG_1(L);
14249  }
14250  }
14251  }
14252 
14253  lua_pushstring(L,"Wrong arguments for overloaded function 'NodeIterator_GetNextSibling'\n"
14254  " Possible C/C++ prototypes are:\n"
14255  " Mezzanine::XML::Node::GetNextSibling() const\n"
14256  " Mezzanine::XML::Node::GetNextSibling(Mezzanine::Char8 const *) const\n");
14257  lua_error(L);return 0;
14258 }
14259 
14260 
14261 static int _wrap_NodeIterator_GetPreviousSibling__SWIG_0(lua_State* L) {
14262  int SWIG_arg = 0;
14264  Mezzanine::XML::Node result;
14265 
14266  SWIG_check_num_args("Mezzanine::XML::Node::GetPreviousSibling",1,1)
14267  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::GetPreviousSibling",1,"Mezzanine::XML::NodeIterator const *");
14268 
14269  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
14270  SWIG_fail_ptr("NodeIterator_GetPreviousSibling",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
14271  }
14272 
14273  result = (*arg1)->GetPreviousSibling();
14274  {
14275  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
14276  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
14277  }
14278  return SWIG_arg;
14279 
14280  if(0) SWIG_fail;
14281 
14282 fail:
14283  lua_error(L);
14284  return SWIG_arg;
14285 }
14286 
14287 
14288 static int _wrap_NodeIterator_GetPreviousSibling__SWIG_1(lua_State* L) {
14289  int SWIG_arg = 0;
14291  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
14292  Mezzanine::XML::Node result;
14293 
14294  SWIG_check_num_args("Mezzanine::XML::Node::GetPreviousSibling",2,2)
14295  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::GetPreviousSibling",1,"Mezzanine::XML::NodeIterator const *");
14296  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::GetPreviousSibling",2,"Mezzanine::Char8 const *");
14297 
14298  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
14299  SWIG_fail_ptr("NodeIterator_GetPreviousSibling",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
14300  }
14301 
14302  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
14303  result = (*arg1)->GetPreviousSibling((Mezzanine::Char8 const *)arg2);
14304  {
14305  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
14306  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
14307  }
14308  return SWIG_arg;
14309 
14310  if(0) SWIG_fail;
14311 
14312 fail:
14313  lua_error(L);
14314  return SWIG_arg;
14315 }
14316 
14317 
14318 static int _wrap_NodeIterator_GetPreviousSibling(lua_State* L) {
14319  int argc;
14320  int argv[3]={
14321  1,2,3
14322  };
14323 
14324  argc = lua_gettop(L);
14325  if (argc == 1) {
14326  int _v;
14327  {
14328  void *ptr;
14329  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeIterator, 0)) {
14330  _v = 0;
14331  } else {
14332  _v = 1;
14333  }
14334  }
14335  if (_v) {
14336  return _wrap_NodeIterator_GetPreviousSibling__SWIG_0(L);
14337  }
14338  }
14339  if (argc == 2) {
14340  int _v;
14341  {
14342  void *ptr;
14343  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeIterator, 0)) {
14344  _v = 0;
14345  } else {
14346  _v = 1;
14347  }
14348  }
14349  if (_v) {
14350  {
14351  _v = SWIG_lua_isnilstring(L,argv[1]);
14352  }
14353  if (_v) {
14354  return _wrap_NodeIterator_GetPreviousSibling__SWIG_1(L);
14355  }
14356  }
14357  }
14358 
14359  lua_pushstring(L,"Wrong arguments for overloaded function 'NodeIterator_GetPreviousSibling'\n"
14360  " Possible C/C++ prototypes are:\n"
14361  " Mezzanine::XML::Node::GetPreviousSibling() const\n"
14362  " Mezzanine::XML::Node::GetPreviousSibling(Mezzanine::Char8 const *) const\n");
14363  lua_error(L);return 0;
14364 }
14365 
14366 
14367 static int _wrap_NodeIterator_GetParent(lua_State* L) {
14368  int SWIG_arg = 0;
14370  Mezzanine::XML::Node result;
14371 
14372  SWIG_check_num_args("Mezzanine::XML::Node::GetParent",1,1)
14373  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::GetParent",1,"Mezzanine::XML::NodeIterator const *");
14374 
14375  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
14376  SWIG_fail_ptr("NodeIterator_GetParent",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
14377  }
14378 
14379  result = (*arg1)->GetParent();
14380  {
14381  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
14382  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
14383  }
14384  return SWIG_arg;
14385 
14386  if(0) SWIG_fail;
14387 
14388 fail:
14389  lua_error(L);
14390  return SWIG_arg;
14391 }
14392 
14393 
14394 static int _wrap_NodeIterator_GetRoot(lua_State* L) {
14395  int SWIG_arg = 0;
14397  Mezzanine::XML::Node result;
14398 
14399  SWIG_check_num_args("Mezzanine::XML::Node::GetRoot",1,1)
14400  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::GetRoot",1,"Mezzanine::XML::NodeIterator const *");
14401 
14402  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
14403  SWIG_fail_ptr("NodeIterator_GetRoot",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
14404  }
14405 
14406  result = (*arg1)->GetRoot();
14407  {
14408  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
14409  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
14410  }
14411  return SWIG_arg;
14412 
14413  if(0) SWIG_fail;
14414 
14415 fail:
14416  lua_error(L);
14417  return SWIG_arg;
14418 }
14419 
14420 
14421 static int _wrap_NodeIterator_GetText(lua_State* L) {
14422  int SWIG_arg = 0;
14424  Mezzanine::XML::NodeText result;
14425 
14426  SWIG_check_num_args("Mezzanine::XML::Node::GetText",1,1)
14427  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::GetText",1,"Mezzanine::XML::NodeIterator const *");
14428 
14429  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
14430  SWIG_fail_ptr("NodeIterator_GetText",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
14431  }
14432 
14433  result = (*arg1)->GetText();
14434  {
14436  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__NodeText,1); SWIG_arg++;
14437  }
14438  return SWIG_arg;
14439 
14440  if(0) SWIG_fail;
14441 
14442 fail:
14443  lua_error(L);
14444  return SWIG_arg;
14445 }
14446 
14447 
14448 static int _wrap_NodeIterator_GetChild(lua_State* L) {
14449  int SWIG_arg = 0;
14451  Mezzanine::String *arg2 = 0 ;
14452  Mezzanine::String temp2 ;
14453  Mezzanine::XML::Node result;
14454 
14455  SWIG_check_num_args("Mezzanine::XML::Node::GetChild",2,2)
14456  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::GetChild",1,"Mezzanine::XML::NodeIterator const *");
14457  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::GetChild",2,"Mezzanine::String const &");
14458 
14459  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
14460  SWIG_fail_ptr("NodeIterator_GetChild",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
14461  }
14462 
14463  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
14464  result = (*arg1)->GetChild((Mezzanine::String const &)*arg2);
14465  {
14466  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
14467  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
14468  }
14469  return SWIG_arg;
14470 
14471  if(0) SWIG_fail;
14472 
14473 fail:
14474  lua_error(L);
14475  return SWIG_arg;
14476 }
14477 
14478 
14479 static int _wrap_NodeIterator_GetAttribute(lua_State* L) {
14480  int SWIG_arg = 0;
14482  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
14484 
14485  SWIG_check_num_args("Mezzanine::XML::Node::GetAttribute",2,2)
14486  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::GetAttribute",1,"Mezzanine::XML::NodeIterator const *");
14487  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::GetAttribute",2,"Mezzanine::Char8 const *");
14488 
14489  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
14490  SWIG_fail_ptr("NodeIterator_GetAttribute",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
14491  }
14492 
14493  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
14494  result = (*arg1)->GetAttribute((Mezzanine::Char8 const *)arg2);
14495  {
14497  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Attribute,1); SWIG_arg++;
14498  }
14499  return SWIG_arg;
14500 
14501  if(0) SWIG_fail;
14502 
14503 fail:
14504  lua_error(L);
14505  return SWIG_arg;
14506 }
14507 
14508 
14509 static int _wrap_NodeIterator_GetChildValue__SWIG_0(lua_State* L) {
14510  int SWIG_arg = 0;
14512  Mezzanine::Char8 *result = 0 ;
14513 
14514  SWIG_check_num_args("Mezzanine::XML::Node::GetChildValue",1,1)
14515  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::GetChildValue",1,"Mezzanine::XML::NodeIterator const *");
14516 
14517  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
14518  SWIG_fail_ptr("NodeIterator_GetChildValue",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
14519  }
14520 
14521  result = (Mezzanine::Char8 *)(*arg1)->GetChildValue();
14522  lua_pushstring(L,(const char *)result); SWIG_arg++;
14523  return SWIG_arg;
14524 
14525  if(0) SWIG_fail;
14526 
14527 fail:
14528  lua_error(L);
14529  return SWIG_arg;
14530 }
14531 
14532 
14533 static int _wrap_NodeIterator_GetChildValue__SWIG_1(lua_State* L) {
14534  int SWIG_arg = 0;
14536  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
14537  Mezzanine::Char8 *result = 0 ;
14538 
14539  SWIG_check_num_args("Mezzanine::XML::Node::GetChildValue",2,2)
14540  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::GetChildValue",1,"Mezzanine::XML::NodeIterator const *");
14541  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::GetChildValue",2,"Mezzanine::Char8 const *");
14542 
14543  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
14544  SWIG_fail_ptr("NodeIterator_GetChildValue",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
14545  }
14546 
14547  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
14548  result = (Mezzanine::Char8 *)(*arg1)->GetChildValue((Mezzanine::Char8 const *)arg2);
14549  lua_pushstring(L,(const char *)result); SWIG_arg++;
14550  return SWIG_arg;
14551 
14552  if(0) SWIG_fail;
14553 
14554 fail:
14555  lua_error(L);
14556  return SWIG_arg;
14557 }
14558 
14559 
14560 static int _wrap_NodeIterator_GetChildValue(lua_State* L) {
14561  int argc;
14562  int argv[3]={
14563  1,2,3
14564  };
14565 
14566  argc = lua_gettop(L);
14567  if (argc == 1) {
14568  int _v;
14569  {
14570  void *ptr;
14571  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeIterator, 0)) {
14572  _v = 0;
14573  } else {
14574  _v = 1;
14575  }
14576  }
14577  if (_v) {
14578  return _wrap_NodeIterator_GetChildValue__SWIG_0(L);
14579  }
14580  }
14581  if (argc == 2) {
14582  int _v;
14583  {
14584  void *ptr;
14585  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeIterator, 0)) {
14586  _v = 0;
14587  } else {
14588  _v = 1;
14589  }
14590  }
14591  if (_v) {
14592  {
14593  _v = SWIG_lua_isnilstring(L,argv[1]);
14594  }
14595  if (_v) {
14596  return _wrap_NodeIterator_GetChildValue__SWIG_1(L);
14597  }
14598  }
14599  }
14600 
14601  lua_pushstring(L,"Wrong arguments for overloaded function 'NodeIterator_GetChildValue'\n"
14602  " Possible C/C++ prototypes are:\n"
14603  " Mezzanine::XML::Node::GetChildValue() const\n"
14604  " Mezzanine::XML::Node::GetChildValue(Mezzanine::Char8 const *) const\n");
14605  lua_error(L);return 0;
14606 }
14607 
14608 
14609 static int _wrap_NodeIterator_SetName(lua_State* L) {
14610  int SWIG_arg = 0;
14612  Mezzanine::String *arg2 = 0 ;
14613  Mezzanine::String temp2 ;
14614  bool result;
14615 
14616  SWIG_check_num_args("Mezzanine::XML::Node::SetName",2,2)
14617  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::SetName",1,"Mezzanine::XML::NodeIterator *");
14618  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::SetName",2,"Mezzanine::String const &");
14619 
14620  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
14621  SWIG_fail_ptr("NodeIterator_SetName",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
14622  }
14623 
14624  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
14625  result = (bool)(*arg1)->SetName((Mezzanine::String const &)*arg2);
14626  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
14627  return SWIG_arg;
14628 
14629  if(0) SWIG_fail;
14630 
14631 fail:
14632  lua_error(L);
14633  return SWIG_arg;
14634 }
14635 
14636 
14637 static int _wrap_NodeIterator_SetValue(lua_State* L) {
14638  int SWIG_arg = 0;
14640  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
14641  bool result;
14642 
14643  SWIG_check_num_args("Mezzanine::XML::Node::SetValue",2,2)
14644  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::SetValue",1,"Mezzanine::XML::NodeIterator *");
14645  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::SetValue",2,"Mezzanine::Char8 const *");
14646 
14647  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
14648  SWIG_fail_ptr("NodeIterator_SetValue",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
14649  }
14650 
14651  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
14652  result = (bool)(*arg1)->SetValue((Mezzanine::Char8 const *)arg2);
14653  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
14654  return SWIG_arg;
14655 
14656  if(0) SWIG_fail;
14657 
14658 fail:
14659  lua_error(L);
14660  return SWIG_arg;
14661 }
14662 
14663 
14664 static int _wrap_NodeIterator_AppendAttribute(lua_State* L) {
14665  int SWIG_arg = 0;
14667  Mezzanine::String *arg2 = 0 ;
14668  Mezzanine::String temp2 ;
14670 
14671  SWIG_check_num_args("Mezzanine::XML::Node::AppendAttribute",2,2)
14672  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::AppendAttribute",1,"Mezzanine::XML::NodeIterator *");
14673  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::AppendAttribute",2,"Mezzanine::String const &");
14674 
14675  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
14676  SWIG_fail_ptr("NodeIterator_AppendAttribute",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
14677  }
14678 
14679  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
14680  result = (*arg1)->AppendAttribute((Mezzanine::String const &)*arg2);
14681  {
14683  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Attribute,1); SWIG_arg++;
14684  }
14685  return SWIG_arg;
14686 
14687  if(0) SWIG_fail;
14688 
14689 fail:
14690  lua_error(L);
14691  return SWIG_arg;
14692 }
14693 
14694 
14695 static int _wrap_NodeIterator_PrependAttribute(lua_State* L) {
14696  int SWIG_arg = 0;
14698  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
14700 
14701  SWIG_check_num_args("Mezzanine::XML::Node::PrependAttribute",2,2)
14702  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::PrependAttribute",1,"Mezzanine::XML::NodeIterator *");
14703  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::PrependAttribute",2,"Mezzanine::Char8 const *");
14704 
14705  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
14706  SWIG_fail_ptr("NodeIterator_PrependAttribute",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
14707  }
14708 
14709  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
14710  result = (*arg1)->PrependAttribute((Mezzanine::Char8 const *)arg2);
14711  {
14713  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Attribute,1); SWIG_arg++;
14714  }
14715  return SWIG_arg;
14716 
14717  if(0) SWIG_fail;
14718 
14719 fail:
14720  lua_error(L);
14721  return SWIG_arg;
14722 }
14723 
14724 
14725 static int _wrap_NodeIterator_InsertAttributeAfter(lua_State* L) {
14726  int SWIG_arg = 0;
14728  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
14729  Mezzanine::XML::Attribute *arg3 = 0 ;
14731 
14732  SWIG_check_num_args("Mezzanine::XML::Node::InsertAttributeAfter",3,3)
14733  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::InsertAttributeAfter",1,"Mezzanine::XML::NodeIterator *");
14734  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::InsertAttributeAfter",2,"Mezzanine::Char8 const *");
14735  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::InsertAttributeAfter",3,"Mezzanine::XML::Attribute const &");
14736 
14737  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
14738  SWIG_fail_ptr("NodeIterator_InsertAttributeAfter",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
14739  }
14740 
14741  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
14742 
14743  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
14744  SWIG_fail_ptr("NodeIterator_InsertAttributeAfter",3,SWIGTYPE_p_Mezzanine__XML__Attribute);
14745  }
14746 
14747  result = (*arg1)->InsertAttributeAfter((Mezzanine::Char8 const *)arg2,(Mezzanine::XML::Attribute const &)*arg3);
14748  {
14750  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Attribute,1); SWIG_arg++;
14751  }
14752  return SWIG_arg;
14753 
14754  if(0) SWIG_fail;
14755 
14756 fail:
14757  lua_error(L);
14758  return SWIG_arg;
14759 }
14760 
14761 
14762 static int _wrap_NodeIterator_InsertAttributeBefore(lua_State* L) {
14763  int SWIG_arg = 0;
14765  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
14766  Mezzanine::XML::Attribute *arg3 = 0 ;
14768 
14769  SWIG_check_num_args("Mezzanine::XML::Node::InsertAttributeBefore",3,3)
14770  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::InsertAttributeBefore",1,"Mezzanine::XML::NodeIterator *");
14771  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::InsertAttributeBefore",2,"Mezzanine::Char8 const *");
14772  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::InsertAttributeBefore",3,"Mezzanine::XML::Attribute const &");
14773 
14774  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
14775  SWIG_fail_ptr("NodeIterator_InsertAttributeBefore",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
14776  }
14777 
14778  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
14779 
14780  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
14781  SWIG_fail_ptr("NodeIterator_InsertAttributeBefore",3,SWIGTYPE_p_Mezzanine__XML__Attribute);
14782  }
14783 
14784  result = (*arg1)->InsertAttributeBefore((Mezzanine::Char8 const *)arg2,(Mezzanine::XML::Attribute const &)*arg3);
14785  {
14787  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Attribute,1); SWIG_arg++;
14788  }
14789  return SWIG_arg;
14790 
14791  if(0) SWIG_fail;
14792 
14793 fail:
14794  lua_error(L);
14795  return SWIG_arg;
14796 }
14797 
14798 
14799 static int _wrap_NodeIterator_AppendCopy__SWIG_0(lua_State* L) {
14800  int SWIG_arg = 0;
14802  Mezzanine::XML::Attribute *arg2 = 0 ;
14804 
14805  SWIG_check_num_args("Mezzanine::XML::Node::AppendCopy",2,2)
14806  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::AppendCopy",1,"Mezzanine::XML::NodeIterator *");
14807  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::AppendCopy",2,"Mezzanine::XML::Attribute const &");
14808 
14809  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
14810  SWIG_fail_ptr("NodeIterator_AppendCopy",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
14811  }
14812 
14813 
14814  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
14815  SWIG_fail_ptr("NodeIterator_AppendCopy",2,SWIGTYPE_p_Mezzanine__XML__Attribute);
14816  }
14817 
14818  result = (*arg1)->AppendCopy((Mezzanine::XML::Attribute const &)*arg2);
14819  {
14821  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Attribute,1); SWIG_arg++;
14822  }
14823  return SWIG_arg;
14824 
14825  if(0) SWIG_fail;
14826 
14827 fail:
14828  lua_error(L);
14829  return SWIG_arg;
14830 }
14831 
14832 
14833 static int _wrap_NodeIterator_AppendCopy__SWIG_1(lua_State* L) {
14834  int SWIG_arg = 0;
14836  Mezzanine::XML::Node *arg2 = 0 ;
14837  Mezzanine::XML::Node result;
14838 
14839  SWIG_check_num_args("Mezzanine::XML::Node::AppendCopy",2,2)
14840  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::AppendCopy",1,"Mezzanine::XML::NodeIterator *");
14841  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::AppendCopy",2,"Mezzanine::XML::Node const &");
14842 
14843  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
14844  SWIG_fail_ptr("NodeIterator_AppendCopy",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
14845  }
14846 
14847 
14848  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Node,0))){
14849  SWIG_fail_ptr("NodeIterator_AppendCopy",2,SWIGTYPE_p_Mezzanine__XML__Node);
14850  }
14851 
14852  result = (*arg1)->AppendCopy((Mezzanine::XML::Node const &)*arg2);
14853  {
14854  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
14855  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
14856  }
14857  return SWIG_arg;
14858 
14859  if(0) SWIG_fail;
14860 
14861 fail:
14862  lua_error(L);
14863  return SWIG_arg;
14864 }
14865 
14866 
14867 static int _wrap_NodeIterator_AppendCopy(lua_State* L) {
14868  int argc;
14869  int argv[3]={
14870  1,2,3
14871  };
14872 
14873  argc = lua_gettop(L);
14874  if (argc == 2) {
14875  int _v;
14876  {
14877  void *ptr;
14878  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeIterator, 0)) {
14879  _v = 0;
14880  } else {
14881  _v = 1;
14882  }
14883  }
14884  if (_v) {
14885  {
14886  void *ptr;
14887  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Attribute, 0)) {
14888  _v = 0;
14889  } else {
14890  _v = 1;
14891  }
14892  }
14893  if (_v) {
14894  return _wrap_NodeIterator_AppendCopy__SWIG_0(L);
14895  }
14896  }
14897  }
14898  if (argc == 2) {
14899  int _v;
14900  {
14901  void *ptr;
14902  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeIterator, 0)) {
14903  _v = 0;
14904  } else {
14905  _v = 1;
14906  }
14907  }
14908  if (_v) {
14909  {
14910  void *ptr;
14911  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
14912  _v = 0;
14913  } else {
14914  _v = 1;
14915  }
14916  }
14917  if (_v) {
14918  return _wrap_NodeIterator_AppendCopy__SWIG_1(L);
14919  }
14920  }
14921  }
14922 
14923  lua_pushstring(L,"Wrong arguments for overloaded function 'NodeIterator_AppendCopy'\n"
14924  " Possible C/C++ prototypes are:\n"
14925  " Mezzanine::XML::Node::AppendCopy(Mezzanine::XML::Attribute const &)\n"
14926  " Mezzanine::XML::Node::AppendCopy(Mezzanine::XML::Node const &)\n");
14927  lua_error(L);return 0;
14928 }
14929 
14930 
14931 static int _wrap_NodeIterator_PrependCopy__SWIG_0(lua_State* L) {
14932  int SWIG_arg = 0;
14934  Mezzanine::XML::Attribute *arg2 = 0 ;
14936 
14937  SWIG_check_num_args("Mezzanine::XML::Node::PrependCopy",2,2)
14938  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::PrependCopy",1,"Mezzanine::XML::NodeIterator *");
14939  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::PrependCopy",2,"Mezzanine::XML::Attribute const &");
14940 
14941  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
14942  SWIG_fail_ptr("NodeIterator_PrependCopy",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
14943  }
14944 
14945 
14946  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
14947  SWIG_fail_ptr("NodeIterator_PrependCopy",2,SWIGTYPE_p_Mezzanine__XML__Attribute);
14948  }
14949 
14950  result = (*arg1)->PrependCopy((Mezzanine::XML::Attribute const &)*arg2);
14951  {
14953  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Attribute,1); SWIG_arg++;
14954  }
14955  return SWIG_arg;
14956 
14957  if(0) SWIG_fail;
14958 
14959 fail:
14960  lua_error(L);
14961  return SWIG_arg;
14962 }
14963 
14964 
14965 static int _wrap_NodeIterator_PrependCopy__SWIG_1(lua_State* L) {
14966  int SWIG_arg = 0;
14968  Mezzanine::XML::Node *arg2 = 0 ;
14969  Mezzanine::XML::Node result;
14970 
14971  SWIG_check_num_args("Mezzanine::XML::Node::PrependCopy",2,2)
14972  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::PrependCopy",1,"Mezzanine::XML::NodeIterator *");
14973  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::PrependCopy",2,"Mezzanine::XML::Node const &");
14974 
14975  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
14976  SWIG_fail_ptr("NodeIterator_PrependCopy",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
14977  }
14978 
14979 
14980  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Node,0))){
14981  SWIG_fail_ptr("NodeIterator_PrependCopy",2,SWIGTYPE_p_Mezzanine__XML__Node);
14982  }
14983 
14984  result = (*arg1)->PrependCopy((Mezzanine::XML::Node const &)*arg2);
14985  {
14986  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
14987  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
14988  }
14989  return SWIG_arg;
14990 
14991  if(0) SWIG_fail;
14992 
14993 fail:
14994  lua_error(L);
14995  return SWIG_arg;
14996 }
14997 
14998 
14999 static int _wrap_NodeIterator_PrependCopy(lua_State* L) {
15000  int argc;
15001  int argv[3]={
15002  1,2,3
15003  };
15004 
15005  argc = lua_gettop(L);
15006  if (argc == 2) {
15007  int _v;
15008  {
15009  void *ptr;
15010  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeIterator, 0)) {
15011  _v = 0;
15012  } else {
15013  _v = 1;
15014  }
15015  }
15016  if (_v) {
15017  {
15018  void *ptr;
15019  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Attribute, 0)) {
15020  _v = 0;
15021  } else {
15022  _v = 1;
15023  }
15024  }
15025  if (_v) {
15026  return _wrap_NodeIterator_PrependCopy__SWIG_0(L);
15027  }
15028  }
15029  }
15030  if (argc == 2) {
15031  int _v;
15032  {
15033  void *ptr;
15034  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeIterator, 0)) {
15035  _v = 0;
15036  } else {
15037  _v = 1;
15038  }
15039  }
15040  if (_v) {
15041  {
15042  void *ptr;
15043  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
15044  _v = 0;
15045  } else {
15046  _v = 1;
15047  }
15048  }
15049  if (_v) {
15050  return _wrap_NodeIterator_PrependCopy__SWIG_1(L);
15051  }
15052  }
15053  }
15054 
15055  lua_pushstring(L,"Wrong arguments for overloaded function 'NodeIterator_PrependCopy'\n"
15056  " Possible C/C++ prototypes are:\n"
15057  " Mezzanine::XML::Node::PrependCopy(Mezzanine::XML::Attribute const &)\n"
15058  " Mezzanine::XML::Node::PrependCopy(Mezzanine::XML::Node const &)\n");
15059  lua_error(L);return 0;
15060 }
15061 
15062 
15063 static int _wrap_NodeIterator_InsertCopyAfter__SWIG_0(lua_State* L) {
15064  int SWIG_arg = 0;
15066  Mezzanine::XML::Attribute *arg2 = 0 ;
15067  Mezzanine::XML::Attribute *arg3 = 0 ;
15069 
15070  SWIG_check_num_args("Mezzanine::XML::Node::InsertCopyAfter",3,3)
15071  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::InsertCopyAfter",1,"Mezzanine::XML::NodeIterator *");
15072  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::InsertCopyAfter",2,"Mezzanine::XML::Attribute const &");
15073  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::InsertCopyAfter",3,"Mezzanine::XML::Attribute const &");
15074 
15075  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
15076  SWIG_fail_ptr("NodeIterator_InsertCopyAfter",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
15077  }
15078 
15079 
15080  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
15081  SWIG_fail_ptr("NodeIterator_InsertCopyAfter",2,SWIGTYPE_p_Mezzanine__XML__Attribute);
15082  }
15083 
15084 
15085  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
15086  SWIG_fail_ptr("NodeIterator_InsertCopyAfter",3,SWIGTYPE_p_Mezzanine__XML__Attribute);
15087  }
15088 
15089  result = (*arg1)->InsertCopyAfter((Mezzanine::XML::Attribute const &)*arg2,(Mezzanine::XML::Attribute const &)*arg3);
15090  {
15092  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Attribute,1); SWIG_arg++;
15093  }
15094  return SWIG_arg;
15095 
15096  if(0) SWIG_fail;
15097 
15098 fail:
15099  lua_error(L);
15100  return SWIG_arg;
15101 }
15102 
15103 
15104 static int _wrap_NodeIterator_InsertCopyAfter__SWIG_1(lua_State* L) {
15105  int SWIG_arg = 0;
15107  Mezzanine::XML::Node *arg2 = 0 ;
15108  Mezzanine::XML::Node *arg3 = 0 ;
15109  Mezzanine::XML::Node result;
15110 
15111  SWIG_check_num_args("Mezzanine::XML::Node::InsertCopyAfter",3,3)
15112  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::InsertCopyAfter",1,"Mezzanine::XML::NodeIterator *");
15113  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::InsertCopyAfter",2,"Mezzanine::XML::Node const &");
15114  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::InsertCopyAfter",3,"Mezzanine::XML::Node const &");
15115 
15116  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
15117  SWIG_fail_ptr("NodeIterator_InsertCopyAfter",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
15118  }
15119 
15120 
15121  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Node,0))){
15122  SWIG_fail_ptr("NodeIterator_InsertCopyAfter",2,SWIGTYPE_p_Mezzanine__XML__Node);
15123  }
15124 
15125 
15126  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__XML__Node,0))){
15127  SWIG_fail_ptr("NodeIterator_InsertCopyAfter",3,SWIGTYPE_p_Mezzanine__XML__Node);
15128  }
15129 
15130  result = (*arg1)->InsertCopyAfter((Mezzanine::XML::Node const &)*arg2,(Mezzanine::XML::Node const &)*arg3);
15131  {
15132  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
15133  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
15134  }
15135  return SWIG_arg;
15136 
15137  if(0) SWIG_fail;
15138 
15139 fail:
15140  lua_error(L);
15141  return SWIG_arg;
15142 }
15143 
15144 
15145 static int _wrap_NodeIterator_InsertCopyAfter(lua_State* L) {
15146  int argc;
15147  int argv[4]={
15148  1,2,3,4
15149  };
15150 
15151  argc = lua_gettop(L);
15152  if (argc == 3) {
15153  int _v;
15154  {
15155  void *ptr;
15156  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeIterator, 0)) {
15157  _v = 0;
15158  } else {
15159  _v = 1;
15160  }
15161  }
15162  if (_v) {
15163  {
15164  void *ptr;
15165  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Attribute, 0)) {
15166  _v = 0;
15167  } else {
15168  _v = 1;
15169  }
15170  }
15171  if (_v) {
15172  {
15173  void *ptr;
15174  if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Attribute, 0)) {
15175  _v = 0;
15176  } else {
15177  _v = 1;
15178  }
15179  }
15180  if (_v) {
15181  return _wrap_NodeIterator_InsertCopyAfter__SWIG_0(L);
15182  }
15183  }
15184  }
15185  }
15186  if (argc == 3) {
15187  int _v;
15188  {
15189  void *ptr;
15190  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeIterator, 0)) {
15191  _v = 0;
15192  } else {
15193  _v = 1;
15194  }
15195  }
15196  if (_v) {
15197  {
15198  void *ptr;
15199  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
15200  _v = 0;
15201  } else {
15202  _v = 1;
15203  }
15204  }
15205  if (_v) {
15206  {
15207  void *ptr;
15208  if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
15209  _v = 0;
15210  } else {
15211  _v = 1;
15212  }
15213  }
15214  if (_v) {
15215  return _wrap_NodeIterator_InsertCopyAfter__SWIG_1(L);
15216  }
15217  }
15218  }
15219  }
15220 
15221  lua_pushstring(L,"Wrong arguments for overloaded function 'NodeIterator_InsertCopyAfter'\n"
15222  " Possible C/C++ prototypes are:\n"
15223  " Mezzanine::XML::Node::InsertCopyAfter(Mezzanine::XML::Attribute const &,Mezzanine::XML::Attribute const &)\n"
15224  " Mezzanine::XML::Node::InsertCopyAfter(Mezzanine::XML::Node const &,Mezzanine::XML::Node const &)\n");
15225  lua_error(L);return 0;
15226 }
15227 
15228 
15229 static int _wrap_NodeIterator_InsertCopyBefore__SWIG_0(lua_State* L) {
15230  int SWIG_arg = 0;
15232  Mezzanine::XML::Attribute *arg2 = 0 ;
15233  Mezzanine::XML::Attribute *arg3 = 0 ;
15235 
15236  SWIG_check_num_args("Mezzanine::XML::Node::InsertCopyBefore",3,3)
15237  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::InsertCopyBefore",1,"Mezzanine::XML::NodeIterator *");
15238  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::InsertCopyBefore",2,"Mezzanine::XML::Attribute const &");
15239  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::InsertCopyBefore",3,"Mezzanine::XML::Attribute const &");
15240 
15241  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
15242  SWIG_fail_ptr("NodeIterator_InsertCopyBefore",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
15243  }
15244 
15245 
15246  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
15247  SWIG_fail_ptr("NodeIterator_InsertCopyBefore",2,SWIGTYPE_p_Mezzanine__XML__Attribute);
15248  }
15249 
15250 
15251  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
15252  SWIG_fail_ptr("NodeIterator_InsertCopyBefore",3,SWIGTYPE_p_Mezzanine__XML__Attribute);
15253  }
15254 
15255  result = (*arg1)->InsertCopyBefore((Mezzanine::XML::Attribute const &)*arg2,(Mezzanine::XML::Attribute const &)*arg3);
15256  {
15258  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Attribute,1); SWIG_arg++;
15259  }
15260  return SWIG_arg;
15261 
15262  if(0) SWIG_fail;
15263 
15264 fail:
15265  lua_error(L);
15266  return SWIG_arg;
15267 }
15268 
15269 
15270 static int _wrap_NodeIterator_InsertCopyBefore__SWIG_1(lua_State* L) {
15271  int SWIG_arg = 0;
15273  Mezzanine::XML::Node *arg2 = 0 ;
15274  Mezzanine::XML::Node *arg3 = 0 ;
15275  Mezzanine::XML::Node result;
15276 
15277  SWIG_check_num_args("Mezzanine::XML::Node::InsertCopyBefore",3,3)
15278  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::InsertCopyBefore",1,"Mezzanine::XML::NodeIterator *");
15279  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::InsertCopyBefore",2,"Mezzanine::XML::Node const &");
15280  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::InsertCopyBefore",3,"Mezzanine::XML::Node const &");
15281 
15282  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
15283  SWIG_fail_ptr("NodeIterator_InsertCopyBefore",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
15284  }
15285 
15286 
15287  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Node,0))){
15288  SWIG_fail_ptr("NodeIterator_InsertCopyBefore",2,SWIGTYPE_p_Mezzanine__XML__Node);
15289  }
15290 
15291 
15292  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__XML__Node,0))){
15293  SWIG_fail_ptr("NodeIterator_InsertCopyBefore",3,SWIGTYPE_p_Mezzanine__XML__Node);
15294  }
15295 
15296  result = (*arg1)->InsertCopyBefore((Mezzanine::XML::Node const &)*arg2,(Mezzanine::XML::Node const &)*arg3);
15297  {
15298  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
15299  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
15300  }
15301  return SWIG_arg;
15302 
15303  if(0) SWIG_fail;
15304 
15305 fail:
15306  lua_error(L);
15307  return SWIG_arg;
15308 }
15309 
15310 
15311 static int _wrap_NodeIterator_InsertCopyBefore(lua_State* L) {
15312  int argc;
15313  int argv[4]={
15314  1,2,3,4
15315  };
15316 
15317  argc = lua_gettop(L);
15318  if (argc == 3) {
15319  int _v;
15320  {
15321  void *ptr;
15322  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeIterator, 0)) {
15323  _v = 0;
15324  } else {
15325  _v = 1;
15326  }
15327  }
15328  if (_v) {
15329  {
15330  void *ptr;
15331  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Attribute, 0)) {
15332  _v = 0;
15333  } else {
15334  _v = 1;
15335  }
15336  }
15337  if (_v) {
15338  {
15339  void *ptr;
15340  if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Attribute, 0)) {
15341  _v = 0;
15342  } else {
15343  _v = 1;
15344  }
15345  }
15346  if (_v) {
15347  return _wrap_NodeIterator_InsertCopyBefore__SWIG_0(L);
15348  }
15349  }
15350  }
15351  }
15352  if (argc == 3) {
15353  int _v;
15354  {
15355  void *ptr;
15356  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeIterator, 0)) {
15357  _v = 0;
15358  } else {
15359  _v = 1;
15360  }
15361  }
15362  if (_v) {
15363  {
15364  void *ptr;
15365  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
15366  _v = 0;
15367  } else {
15368  _v = 1;
15369  }
15370  }
15371  if (_v) {
15372  {
15373  void *ptr;
15374  if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
15375  _v = 0;
15376  } else {
15377  _v = 1;
15378  }
15379  }
15380  if (_v) {
15381  return _wrap_NodeIterator_InsertCopyBefore__SWIG_1(L);
15382  }
15383  }
15384  }
15385  }
15386 
15387  lua_pushstring(L,"Wrong arguments for overloaded function 'NodeIterator_InsertCopyBefore'\n"
15388  " Possible C/C++ prototypes are:\n"
15389  " Mezzanine::XML::Node::InsertCopyBefore(Mezzanine::XML::Attribute const &,Mezzanine::XML::Attribute const &)\n"
15390  " Mezzanine::XML::Node::InsertCopyBefore(Mezzanine::XML::Node const &,Mezzanine::XML::Node const &)\n");
15391  lua_error(L);return 0;
15392 }
15393 
15394 
15395 static int _wrap_NodeIterator_AppendChild__SWIG_0(lua_State* L) {
15396  int SWIG_arg = 0;
15399  Mezzanine::XML::Node result;
15400 
15401  SWIG_check_num_args("Mezzanine::XML::Node::AppendChild",2,2)
15402  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::AppendChild",1,"Mezzanine::XML::NodeIterator *");
15403  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::AppendChild",2,"Mezzanine::XML::NodeType");
15404 
15405  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
15406  SWIG_fail_ptr("NodeIterator_AppendChild",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
15407  }
15408 
15409  arg2 = (Mezzanine::XML::NodeType)(int)lua_tonumber(L, 2);
15410  result = (*arg1)->AppendChild(arg2);
15411  {
15412  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
15413  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
15414  }
15415  return SWIG_arg;
15416 
15417  if(0) SWIG_fail;
15418 
15419 fail:
15420  lua_error(L);
15421  return SWIG_arg;
15422 }
15423 
15424 
15425 static int _wrap_NodeIterator_AppendChild__SWIG_1(lua_State* L) {
15426  int SWIG_arg = 0;
15428  Mezzanine::XML::Node result;
15429 
15430  SWIG_check_num_args("Mezzanine::XML::Node::AppendChild",1,1)
15431  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::AppendChild",1,"Mezzanine::XML::NodeIterator *");
15432 
15433  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
15434  SWIG_fail_ptr("NodeIterator_AppendChild",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
15435  }
15436 
15437  result = (*arg1)->AppendChild();
15438  {
15439  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
15440  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
15441  }
15442  return SWIG_arg;
15443 
15444  if(0) SWIG_fail;
15445 
15446 fail:
15447  lua_error(L);
15448  return SWIG_arg;
15449 }
15450 
15451 
15452 static int _wrap_NodeIterator_AppendChild__SWIG_2(lua_State* L) {
15453  int SWIG_arg = 0;
15455  Mezzanine::String *arg2 = 0 ;
15456  Mezzanine::String temp2 ;
15457  Mezzanine::XML::Node result;
15458 
15459  SWIG_check_num_args("Mezzanine::XML::Node::AppendChild",2,2)
15460  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::AppendChild",1,"Mezzanine::XML::NodeIterator *");
15461  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::AppendChild",2,"Mezzanine::String const &");
15462 
15463  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
15464  SWIG_fail_ptr("NodeIterator_AppendChild",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
15465  }
15466 
15467  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
15468  result = (*arg1)->AppendChild((Mezzanine::String const &)*arg2);
15469  {
15470  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
15471  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
15472  }
15473  return SWIG_arg;
15474 
15475  if(0) SWIG_fail;
15476 
15477 fail:
15478  lua_error(L);
15479  return SWIG_arg;
15480 }
15481 
15482 
15483 static int _wrap_NodeIterator_AppendChild(lua_State* L) {
15484  int argc;
15485  int argv[3]={
15486  1,2,3
15487  };
15488 
15489  argc = lua_gettop(L);
15490  if (argc == 1) {
15491  int _v;
15492  {
15493  void *ptr;
15494  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeIterator, 0)) {
15495  _v = 0;
15496  } else {
15497  _v = 1;
15498  }
15499  }
15500  if (_v) {
15501  return _wrap_NodeIterator_AppendChild__SWIG_1(L);
15502  }
15503  }
15504  if (argc == 2) {
15505  int _v;
15506  {
15507  void *ptr;
15508  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeIterator, 0)) {
15509  _v = 0;
15510  } else {
15511  _v = 1;
15512  }
15513  }
15514  if (_v) {
15515  {
15516  _v = lua_isnumber(L,argv[1]);
15517  }
15518  if (_v) {
15519  return _wrap_NodeIterator_AppendChild__SWIG_0(L);
15520  }
15521  }
15522  }
15523  if (argc == 2) {
15524  int _v;
15525  {
15526  void *ptr;
15527  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeIterator, 0)) {
15528  _v = 0;
15529  } else {
15530  _v = 1;
15531  }
15532  }
15533  if (_v) {
15534  {
15535  _v = lua_isstring(L,argv[1]);
15536  }
15537  if (_v) {
15538  return _wrap_NodeIterator_AppendChild__SWIG_2(L);
15539  }
15540  }
15541  }
15542 
15543  lua_pushstring(L,"Wrong arguments for overloaded function 'NodeIterator_AppendChild'\n"
15544  " Possible C/C++ prototypes are:\n"
15545  " Mezzanine::XML::Node::AppendChild(Mezzanine::XML::NodeType)\n"
15546  " Mezzanine::XML::Node::AppendChild()\n"
15547  " Mezzanine::XML::Node::AppendChild(Mezzanine::String const &)\n");
15548  lua_error(L);return 0;
15549 }
15550 
15551 
15552 static int _wrap_NodeIterator_PrependChild__SWIG_0(lua_State* L) {
15553  int SWIG_arg = 0;
15556  Mezzanine::XML::Node result;
15557 
15558  SWIG_check_num_args("Mezzanine::XML::Node::PrependChild",2,2)
15559  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::PrependChild",1,"Mezzanine::XML::NodeIterator *");
15560  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::PrependChild",2,"Mezzanine::XML::NodeType");
15561 
15562  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
15563  SWIG_fail_ptr("NodeIterator_PrependChild",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
15564  }
15565 
15566  arg2 = (Mezzanine::XML::NodeType)(int)lua_tonumber(L, 2);
15567  result = (*arg1)->PrependChild(arg2);
15568  {
15569  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
15570  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
15571  }
15572  return SWIG_arg;
15573 
15574  if(0) SWIG_fail;
15575 
15576 fail:
15577  lua_error(L);
15578  return SWIG_arg;
15579 }
15580 
15581 
15582 static int _wrap_NodeIterator_PrependChild__SWIG_1(lua_State* L) {
15583  int SWIG_arg = 0;
15585  Mezzanine::XML::Node result;
15586 
15587  SWIG_check_num_args("Mezzanine::XML::Node::PrependChild",1,1)
15588  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::PrependChild",1,"Mezzanine::XML::NodeIterator *");
15589 
15590  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
15591  SWIG_fail_ptr("NodeIterator_PrependChild",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
15592  }
15593 
15594  result = (*arg1)->PrependChild();
15595  {
15596  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
15597  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
15598  }
15599  return SWIG_arg;
15600 
15601  if(0) SWIG_fail;
15602 
15603 fail:
15604  lua_error(L);
15605  return SWIG_arg;
15606 }
15607 
15608 
15609 static int _wrap_NodeIterator_PrependChild__SWIG_2(lua_State* L) {
15610  int SWIG_arg = 0;
15612  Mezzanine::String *arg2 = 0 ;
15613  Mezzanine::String temp2 ;
15614  Mezzanine::XML::Node result;
15615 
15616  SWIG_check_num_args("Mezzanine::XML::Node::PrependChild",2,2)
15617  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::PrependChild",1,"Mezzanine::XML::NodeIterator *");
15618  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::PrependChild",2,"Mezzanine::String const &");
15619 
15620  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
15621  SWIG_fail_ptr("NodeIterator_PrependChild",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
15622  }
15623 
15624  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
15625  result = (*arg1)->PrependChild((Mezzanine::String const &)*arg2);
15626  {
15627  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
15628  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
15629  }
15630  return SWIG_arg;
15631 
15632  if(0) SWIG_fail;
15633 
15634 fail:
15635  lua_error(L);
15636  return SWIG_arg;
15637 }
15638 
15639 
15640 static int _wrap_NodeIterator_PrependChild(lua_State* L) {
15641  int argc;
15642  int argv[3]={
15643  1,2,3
15644  };
15645 
15646  argc = lua_gettop(L);
15647  if (argc == 1) {
15648  int _v;
15649  {
15650  void *ptr;
15651  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeIterator, 0)) {
15652  _v = 0;
15653  } else {
15654  _v = 1;
15655  }
15656  }
15657  if (_v) {
15658  return _wrap_NodeIterator_PrependChild__SWIG_1(L);
15659  }
15660  }
15661  if (argc == 2) {
15662  int _v;
15663  {
15664  void *ptr;
15665  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeIterator, 0)) {
15666  _v = 0;
15667  } else {
15668  _v = 1;
15669  }
15670  }
15671  if (_v) {
15672  {
15673  _v = lua_isnumber(L,argv[1]);
15674  }
15675  if (_v) {
15676  return _wrap_NodeIterator_PrependChild__SWIG_0(L);
15677  }
15678  }
15679  }
15680  if (argc == 2) {
15681  int _v;
15682  {
15683  void *ptr;
15684  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeIterator, 0)) {
15685  _v = 0;
15686  } else {
15687  _v = 1;
15688  }
15689  }
15690  if (_v) {
15691  {
15692  _v = lua_isstring(L,argv[1]);
15693  }
15694  if (_v) {
15695  return _wrap_NodeIterator_PrependChild__SWIG_2(L);
15696  }
15697  }
15698  }
15699 
15700  lua_pushstring(L,"Wrong arguments for overloaded function 'NodeIterator_PrependChild'\n"
15701  " Possible C/C++ prototypes are:\n"
15702  " Mezzanine::XML::Node::PrependChild(Mezzanine::XML::NodeType)\n"
15703  " Mezzanine::XML::Node::PrependChild()\n"
15704  " Mezzanine::XML::Node::PrependChild(Mezzanine::String const &)\n");
15705  lua_error(L);return 0;
15706 }
15707 
15708 
15709 static int _wrap_NodeIterator_InsertChildAfter__SWIG_0(lua_State* L) {
15710  int SWIG_arg = 0;
15713  Mezzanine::XML::Node *arg3 = 0 ;
15714  Mezzanine::XML::Node result;
15715 
15716  SWIG_check_num_args("Mezzanine::XML::Node::InsertChildAfter",3,3)
15717  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::InsertChildAfter",1,"Mezzanine::XML::NodeIterator *");
15718  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::InsertChildAfter",2,"Mezzanine::XML::NodeType");
15719  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::InsertChildAfter",3,"Mezzanine::XML::Node const &");
15720 
15721  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
15722  SWIG_fail_ptr("NodeIterator_InsertChildAfter",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
15723  }
15724 
15725  arg2 = (Mezzanine::XML::NodeType)(int)lua_tonumber(L, 2);
15726 
15727  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__XML__Node,0))){
15728  SWIG_fail_ptr("NodeIterator_InsertChildAfter",3,SWIGTYPE_p_Mezzanine__XML__Node);
15729  }
15730 
15731  result = (*arg1)->InsertChildAfter(arg2,(Mezzanine::XML::Node const &)*arg3);
15732  {
15733  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
15734  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
15735  }
15736  return SWIG_arg;
15737 
15738  if(0) SWIG_fail;
15739 
15740 fail:
15741  lua_error(L);
15742  return SWIG_arg;
15743 }
15744 
15745 
15746 static int _wrap_NodeIterator_InsertChildAfter__SWIG_1(lua_State* L) {
15747  int SWIG_arg = 0;
15749  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
15750  Mezzanine::XML::Node *arg3 = 0 ;
15751  Mezzanine::XML::Node result;
15752 
15753  SWIG_check_num_args("Mezzanine::XML::Node::InsertChildAfter",3,3)
15754  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::InsertChildAfter",1,"Mezzanine::XML::NodeIterator *");
15755  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::InsertChildAfter",2,"Mezzanine::Char8 const *");
15756  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::InsertChildAfter",3,"Mezzanine::XML::Node const &");
15757 
15758  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
15759  SWIG_fail_ptr("NodeIterator_InsertChildAfter",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
15760  }
15761 
15762  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
15763 
15764  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__XML__Node,0))){
15765  SWIG_fail_ptr("NodeIterator_InsertChildAfter",3,SWIGTYPE_p_Mezzanine__XML__Node);
15766  }
15767 
15768  result = (*arg1)->InsertChildAfter((Mezzanine::Char8 const *)arg2,(Mezzanine::XML::Node const &)*arg3);
15769  {
15770  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
15771  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
15772  }
15773  return SWIG_arg;
15774 
15775  if(0) SWIG_fail;
15776 
15777 fail:
15778  lua_error(L);
15779  return SWIG_arg;
15780 }
15781 
15782 
15783 static int _wrap_NodeIterator_InsertChildAfter(lua_State* L) {
15784  int argc;
15785  int argv[4]={
15786  1,2,3,4
15787  };
15788 
15789  argc = lua_gettop(L);
15790  if (argc == 3) {
15791  int _v;
15792  {
15793  void *ptr;
15794  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeIterator, 0)) {
15795  _v = 0;
15796  } else {
15797  _v = 1;
15798  }
15799  }
15800  if (_v) {
15801  {
15802  _v = lua_isnumber(L,argv[1]);
15803  }
15804  if (_v) {
15805  {
15806  void *ptr;
15807  if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
15808  _v = 0;
15809  } else {
15810  _v = 1;
15811  }
15812  }
15813  if (_v) {
15814  return _wrap_NodeIterator_InsertChildAfter__SWIG_0(L);
15815  }
15816  }
15817  }
15818  }
15819  if (argc == 3) {
15820  int _v;
15821  {
15822  void *ptr;
15823  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeIterator, 0)) {
15824  _v = 0;
15825  } else {
15826  _v = 1;
15827  }
15828  }
15829  if (_v) {
15830  {
15831  _v = SWIG_lua_isnilstring(L,argv[1]);
15832  }
15833  if (_v) {
15834  {
15835  void *ptr;
15836  if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
15837  _v = 0;
15838  } else {
15839  _v = 1;
15840  }
15841  }
15842  if (_v) {
15843  return _wrap_NodeIterator_InsertChildAfter__SWIG_1(L);
15844  }
15845  }
15846  }
15847  }
15848 
15849  lua_pushstring(L,"Wrong arguments for overloaded function 'NodeIterator_InsertChildAfter'\n"
15850  " Possible C/C++ prototypes are:\n"
15851  " Mezzanine::XML::Node::InsertChildAfter(Mezzanine::XML::NodeType,Mezzanine::XML::Node const &)\n"
15852  " Mezzanine::XML::Node::InsertChildAfter(Mezzanine::Char8 const *,Mezzanine::XML::Node const &)\n");
15853  lua_error(L);return 0;
15854 }
15855 
15856 
15857 static int _wrap_NodeIterator_InsertChildBefore__SWIG_0(lua_State* L) {
15858  int SWIG_arg = 0;
15861  Mezzanine::XML::Node *arg3 = 0 ;
15862  Mezzanine::XML::Node result;
15863 
15864  SWIG_check_num_args("Mezzanine::XML::Node::InsertChildBefore",3,3)
15865  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::InsertChildBefore",1,"Mezzanine::XML::NodeIterator *");
15866  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::InsertChildBefore",2,"Mezzanine::XML::NodeType");
15867  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::InsertChildBefore",3,"Mezzanine::XML::Node const &");
15868 
15869  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
15870  SWIG_fail_ptr("NodeIterator_InsertChildBefore",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
15871  }
15872 
15873  arg2 = (Mezzanine::XML::NodeType)(int)lua_tonumber(L, 2);
15874 
15875  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__XML__Node,0))){
15876  SWIG_fail_ptr("NodeIterator_InsertChildBefore",3,SWIGTYPE_p_Mezzanine__XML__Node);
15877  }
15878 
15879  result = (*arg1)->InsertChildBefore(arg2,(Mezzanine::XML::Node const &)*arg3);
15880  {
15881  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
15882  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
15883  }
15884  return SWIG_arg;
15885 
15886  if(0) SWIG_fail;
15887 
15888 fail:
15889  lua_error(L);
15890  return SWIG_arg;
15891 }
15892 
15893 
15894 static int _wrap_NodeIterator_InsertChildBefore__SWIG_1(lua_State* L) {
15895  int SWIG_arg = 0;
15897  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
15898  Mezzanine::XML::Node *arg3 = 0 ;
15899  Mezzanine::XML::Node result;
15900 
15901  SWIG_check_num_args("Mezzanine::XML::Node::InsertChildBefore",3,3)
15902  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::InsertChildBefore",1,"Mezzanine::XML::NodeIterator *");
15903  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::InsertChildBefore",2,"Mezzanine::Char8 const *");
15904  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::InsertChildBefore",3,"Mezzanine::XML::Node const &");
15905 
15906  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
15907  SWIG_fail_ptr("NodeIterator_InsertChildBefore",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
15908  }
15909 
15910  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
15911 
15912  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__XML__Node,0))){
15913  SWIG_fail_ptr("NodeIterator_InsertChildBefore",3,SWIGTYPE_p_Mezzanine__XML__Node);
15914  }
15915 
15916  result = (*arg1)->InsertChildBefore((Mezzanine::Char8 const *)arg2,(Mezzanine::XML::Node const &)*arg3);
15917  {
15918  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
15919  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
15920  }
15921  return SWIG_arg;
15922 
15923  if(0) SWIG_fail;
15924 
15925 fail:
15926  lua_error(L);
15927  return SWIG_arg;
15928 }
15929 
15930 
15931 static int _wrap_NodeIterator_InsertChildBefore(lua_State* L) {
15932  int argc;
15933  int argv[4]={
15934  1,2,3,4
15935  };
15936 
15937  argc = lua_gettop(L);
15938  if (argc == 3) {
15939  int _v;
15940  {
15941  void *ptr;
15942  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeIterator, 0)) {
15943  _v = 0;
15944  } else {
15945  _v = 1;
15946  }
15947  }
15948  if (_v) {
15949  {
15950  _v = lua_isnumber(L,argv[1]);
15951  }
15952  if (_v) {
15953  {
15954  void *ptr;
15955  if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
15956  _v = 0;
15957  } else {
15958  _v = 1;
15959  }
15960  }
15961  if (_v) {
15962  return _wrap_NodeIterator_InsertChildBefore__SWIG_0(L);
15963  }
15964  }
15965  }
15966  }
15967  if (argc == 3) {
15968  int _v;
15969  {
15970  void *ptr;
15971  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeIterator, 0)) {
15972  _v = 0;
15973  } else {
15974  _v = 1;
15975  }
15976  }
15977  if (_v) {
15978  {
15979  _v = SWIG_lua_isnilstring(L,argv[1]);
15980  }
15981  if (_v) {
15982  {
15983  void *ptr;
15984  if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
15985  _v = 0;
15986  } else {
15987  _v = 1;
15988  }
15989  }
15990  if (_v) {
15991  return _wrap_NodeIterator_InsertChildBefore__SWIG_1(L);
15992  }
15993  }
15994  }
15995  }
15996 
15997  lua_pushstring(L,"Wrong arguments for overloaded function 'NodeIterator_InsertChildBefore'\n"
15998  " Possible C/C++ prototypes are:\n"
15999  " Mezzanine::XML::Node::InsertChildBefore(Mezzanine::XML::NodeType,Mezzanine::XML::Node const &)\n"
16000  " Mezzanine::XML::Node::InsertChildBefore(Mezzanine::Char8 const *,Mezzanine::XML::Node const &)\n");
16001  lua_error(L);return 0;
16002 }
16003 
16004 
16005 static int _wrap_NodeIterator_RemoveAttribute__SWIG_0(lua_State* L) {
16006  int SWIG_arg = 0;
16008  Mezzanine::XML::Attribute *arg2 = 0 ;
16009  bool result;
16010 
16011  SWIG_check_num_args("Mezzanine::XML::Node::RemoveAttribute",2,2)
16012  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::RemoveAttribute",1,"Mezzanine::XML::NodeIterator *");
16013  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::RemoveAttribute",2,"Mezzanine::XML::Attribute const &");
16014 
16015  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
16016  SWIG_fail_ptr("NodeIterator_RemoveAttribute",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
16017  }
16018 
16019 
16020  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
16021  SWIG_fail_ptr("NodeIterator_RemoveAttribute",2,SWIGTYPE_p_Mezzanine__XML__Attribute);
16022  }
16023 
16024  result = (bool)(*arg1)->RemoveAttribute((Mezzanine::XML::Attribute const &)*arg2);
16025  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
16026  return SWIG_arg;
16027 
16028  if(0) SWIG_fail;
16029 
16030 fail:
16031  lua_error(L);
16032  return SWIG_arg;
16033 }
16034 
16035 
16036 static int _wrap_NodeIterator_RemoveAttribute__SWIG_1(lua_State* L) {
16037  int SWIG_arg = 0;
16039  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
16040  bool result;
16041 
16042  SWIG_check_num_args("Mezzanine::XML::Node::RemoveAttribute",2,2)
16043  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::RemoveAttribute",1,"Mezzanine::XML::NodeIterator *");
16044  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::RemoveAttribute",2,"Mezzanine::Char8 const *");
16045 
16046  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
16047  SWIG_fail_ptr("NodeIterator_RemoveAttribute",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
16048  }
16049 
16050  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
16051  result = (bool)(*arg1)->RemoveAttribute((Mezzanine::Char8 const *)arg2);
16052  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
16053  return SWIG_arg;
16054 
16055  if(0) SWIG_fail;
16056 
16057 fail:
16058  lua_error(L);
16059  return SWIG_arg;
16060 }
16061 
16062 
16063 static int _wrap_NodeIterator_RemoveAttribute(lua_State* L) {
16064  int argc;
16065  int argv[3]={
16066  1,2,3
16067  };
16068 
16069  argc = lua_gettop(L);
16070  if (argc == 2) {
16071  int _v;
16072  {
16073  void *ptr;
16074  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeIterator, 0)) {
16075  _v = 0;
16076  } else {
16077  _v = 1;
16078  }
16079  }
16080  if (_v) {
16081  {
16082  void *ptr;
16083  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Attribute, 0)) {
16084  _v = 0;
16085  } else {
16086  _v = 1;
16087  }
16088  }
16089  if (_v) {
16090  return _wrap_NodeIterator_RemoveAttribute__SWIG_0(L);
16091  }
16092  }
16093  }
16094  if (argc == 2) {
16095  int _v;
16096  {
16097  void *ptr;
16098  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeIterator, 0)) {
16099  _v = 0;
16100  } else {
16101  _v = 1;
16102  }
16103  }
16104  if (_v) {
16105  {
16106  _v = SWIG_lua_isnilstring(L,argv[1]);
16107  }
16108  if (_v) {
16109  return _wrap_NodeIterator_RemoveAttribute__SWIG_1(L);
16110  }
16111  }
16112  }
16113 
16114  lua_pushstring(L,"Wrong arguments for overloaded function 'NodeIterator_RemoveAttribute'\n"
16115  " Possible C/C++ prototypes are:\n"
16116  " Mezzanine::XML::Node::RemoveAttribute(Mezzanine::XML::Attribute const &)\n"
16117  " Mezzanine::XML::Node::RemoveAttribute(Mezzanine::Char8 const *)\n");
16118  lua_error(L);return 0;
16119 }
16120 
16121 
16122 static int _wrap_NodeIterator_RemoveChild__SWIG_0(lua_State* L) {
16123  int SWIG_arg = 0;
16125  Mezzanine::XML::Node *arg2 = 0 ;
16126  bool result;
16127 
16128  SWIG_check_num_args("Mezzanine::XML::Node::RemoveChild",2,2)
16129  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::RemoveChild",1,"Mezzanine::XML::NodeIterator *");
16130  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::RemoveChild",2,"Mezzanine::XML::Node const &");
16131 
16132  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
16133  SWIG_fail_ptr("NodeIterator_RemoveChild",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
16134  }
16135 
16136 
16137  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Node,0))){
16138  SWIG_fail_ptr("NodeIterator_RemoveChild",2,SWIGTYPE_p_Mezzanine__XML__Node);
16139  }
16140 
16141  result = (bool)(*arg1)->RemoveChild((Mezzanine::XML::Node const &)*arg2);
16142  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
16143  return SWIG_arg;
16144 
16145  if(0) SWIG_fail;
16146 
16147 fail:
16148  lua_error(L);
16149  return SWIG_arg;
16150 }
16151 
16152 
16153 static int _wrap_NodeIterator_RemoveChild__SWIG_1(lua_State* L) {
16154  int SWIG_arg = 0;
16156  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
16157  bool result;
16158 
16159  SWIG_check_num_args("Mezzanine::XML::Node::RemoveChild",2,2)
16160  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::RemoveChild",1,"Mezzanine::XML::NodeIterator *");
16161  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::RemoveChild",2,"Mezzanine::Char8 const *");
16162 
16163  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
16164  SWIG_fail_ptr("NodeIterator_RemoveChild",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
16165  }
16166 
16167  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
16168  result = (bool)(*arg1)->RemoveChild((Mezzanine::Char8 const *)arg2);
16169  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
16170  return SWIG_arg;
16171 
16172  if(0) SWIG_fail;
16173 
16174 fail:
16175  lua_error(L);
16176  return SWIG_arg;
16177 }
16178 
16179 
16180 static int _wrap_NodeIterator_RemoveChild(lua_State* L) {
16181  int argc;
16182  int argv[3]={
16183  1,2,3
16184  };
16185 
16186  argc = lua_gettop(L);
16187  if (argc == 2) {
16188  int _v;
16189  {
16190  void *ptr;
16191  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeIterator, 0)) {
16192  _v = 0;
16193  } else {
16194  _v = 1;
16195  }
16196  }
16197  if (_v) {
16198  {
16199  void *ptr;
16200  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
16201  _v = 0;
16202  } else {
16203  _v = 1;
16204  }
16205  }
16206  if (_v) {
16207  return _wrap_NodeIterator_RemoveChild__SWIG_0(L);
16208  }
16209  }
16210  }
16211  if (argc == 2) {
16212  int _v;
16213  {
16214  void *ptr;
16215  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeIterator, 0)) {
16216  _v = 0;
16217  } else {
16218  _v = 1;
16219  }
16220  }
16221  if (_v) {
16222  {
16223  _v = SWIG_lua_isnilstring(L,argv[1]);
16224  }
16225  if (_v) {
16226  return _wrap_NodeIterator_RemoveChild__SWIG_1(L);
16227  }
16228  }
16229  }
16230 
16231  lua_pushstring(L,"Wrong arguments for overloaded function 'NodeIterator_RemoveChild'\n"
16232  " Possible C/C++ prototypes are:\n"
16233  " Mezzanine::XML::Node::RemoveChild(Mezzanine::XML::Node const &)\n"
16234  " Mezzanine::XML::Node::RemoveChild(Mezzanine::Char8 const *)\n");
16235  lua_error(L);return 0;
16236 }
16237 
16238 
16239 static int _wrap_NodeIterator_FindChildbyAttribute__SWIG_0(lua_State* L) {
16240  int SWIG_arg = 0;
16242  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
16243  Mezzanine::Char8 *arg3 = (Mezzanine::Char8 *) 0 ;
16244  Mezzanine::Char8 *arg4 = (Mezzanine::Char8 *) 0 ;
16245  Mezzanine::XML::Node result;
16246 
16247  SWIG_check_num_args("Mezzanine::XML::Node::FindChildbyAttribute",4,4)
16248  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::FindChildbyAttribute",1,"Mezzanine::XML::NodeIterator const *");
16249  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::FindChildbyAttribute",2,"Mezzanine::Char8 const *");
16250  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::FindChildbyAttribute",3,"Mezzanine::Char8 const *");
16251  if(!SWIG_lua_isnilstring(L,4)) SWIG_fail_arg("Mezzanine::XML::Node::FindChildbyAttribute",4,"Mezzanine::Char8 const *");
16252 
16253  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
16254  SWIG_fail_ptr("NodeIterator_FindChildbyAttribute",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
16255  }
16256 
16257  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
16258  arg3 = (Mezzanine::Char8 *)lua_tostring(L, 3);
16259  arg4 = (Mezzanine::Char8 *)lua_tostring(L, 4);
16260  result = (*arg1)->FindChildbyAttribute((Mezzanine::Char8 const *)arg2,(Mezzanine::Char8 const *)arg3,(Mezzanine::Char8 const *)arg4);
16261  {
16262  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
16263  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
16264  }
16265  return SWIG_arg;
16266 
16267  if(0) SWIG_fail;
16268 
16269 fail:
16270  lua_error(L);
16271  return SWIG_arg;
16272 }
16273 
16274 
16275 static int _wrap_NodeIterator_FindChildbyAttribute__SWIG_1(lua_State* L) {
16276  int SWIG_arg = 0;
16278  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
16279  Mezzanine::Char8 *arg3 = (Mezzanine::Char8 *) 0 ;
16280  Mezzanine::XML::Node result;
16281 
16282  SWIG_check_num_args("Mezzanine::XML::Node::FindChildbyAttribute",3,3)
16283  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::FindChildbyAttribute",1,"Mezzanine::XML::NodeIterator const *");
16284  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::FindChildbyAttribute",2,"Mezzanine::Char8 const *");
16285  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::FindChildbyAttribute",3,"Mezzanine::Char8 const *");
16286 
16287  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
16288  SWIG_fail_ptr("NodeIterator_FindChildbyAttribute",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
16289  }
16290 
16291  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
16292  arg3 = (Mezzanine::Char8 *)lua_tostring(L, 3);
16293  result = (*arg1)->FindChildbyAttribute((Mezzanine::Char8 const *)arg2,(Mezzanine::Char8 const *)arg3);
16294  {
16295  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
16296  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
16297  }
16298  return SWIG_arg;
16299 
16300  if(0) SWIG_fail;
16301 
16302 fail:
16303  lua_error(L);
16304  return SWIG_arg;
16305 }
16306 
16307 
16308 static int _wrap_NodeIterator_FindChildbyAttribute(lua_State* L) {
16309  int argc;
16310  int argv[5]={
16311  1,2,3,4,5
16312  };
16313 
16314  argc = lua_gettop(L);
16315  if (argc == 3) {
16316  int _v;
16317  {
16318  void *ptr;
16319  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeIterator, 0)) {
16320  _v = 0;
16321  } else {
16322  _v = 1;
16323  }
16324  }
16325  if (_v) {
16326  {
16327  _v = SWIG_lua_isnilstring(L,argv[1]);
16328  }
16329  if (_v) {
16330  {
16331  _v = SWIG_lua_isnilstring(L,argv[2]);
16332  }
16333  if (_v) {
16334  return _wrap_NodeIterator_FindChildbyAttribute__SWIG_1(L);
16335  }
16336  }
16337  }
16338  }
16339  if (argc == 4) {
16340  int _v;
16341  {
16342  void *ptr;
16343  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeIterator, 0)) {
16344  _v = 0;
16345  } else {
16346  _v = 1;
16347  }
16348  }
16349  if (_v) {
16350  {
16351  _v = SWIG_lua_isnilstring(L,argv[1]);
16352  }
16353  if (_v) {
16354  {
16355  _v = SWIG_lua_isnilstring(L,argv[2]);
16356  }
16357  if (_v) {
16358  {
16359  _v = SWIG_lua_isnilstring(L,argv[3]);
16360  }
16361  if (_v) {
16362  return _wrap_NodeIterator_FindChildbyAttribute__SWIG_0(L);
16363  }
16364  }
16365  }
16366  }
16367  }
16368 
16369  lua_pushstring(L,"Wrong arguments for overloaded function 'NodeIterator_FindChildbyAttribute'\n"
16370  " Possible C/C++ prototypes are:\n"
16371  " Mezzanine::XML::Node::FindChildbyAttribute(Mezzanine::Char8 const *,Mezzanine::Char8 const *,Mezzanine::Char8 const *) const\n"
16372  " Mezzanine::XML::Node::FindChildbyAttribute(Mezzanine::Char8 const *,Mezzanine::Char8 const *) const\n");
16373  lua_error(L);return 0;
16374 }
16375 
16376 
16377 static int _wrap_NodeIterator_Path__SWIG_0(lua_State* L) {
16378  int SWIG_arg = 0;
16380  Mezzanine::Char8 arg2 ;
16381  Mezzanine::String result;
16382 
16383  SWIG_check_num_args("Mezzanine::XML::Node::Path",2,2)
16384  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Path",1,"Mezzanine::XML::NodeIterator const *");
16385  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::Path",2,"Mezzanine::Char8");
16386 
16387  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
16388  SWIG_fail_ptr("NodeIterator_Path",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
16389  }
16390 
16391  arg2 = (lua_tostring(L, 2))[0];
16392  result = (*arg1)->Path(arg2);
16393  lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
16394  return SWIG_arg;
16395 
16396  if(0) SWIG_fail;
16397 
16398 fail:
16399  lua_error(L);
16400  return SWIG_arg;
16401 }
16402 
16403 
16404 static int _wrap_NodeIterator_Path__SWIG_1(lua_State* L) {
16405  int SWIG_arg = 0;
16407  Mezzanine::String result;
16408 
16409  SWIG_check_num_args("Mezzanine::XML::Node::Path",1,1)
16410  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Path",1,"Mezzanine::XML::NodeIterator const *");
16411 
16412  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
16413  SWIG_fail_ptr("NodeIterator_Path",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
16414  }
16415 
16416  result = (*arg1)->Path();
16417  lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
16418  return SWIG_arg;
16419 
16420  if(0) SWIG_fail;
16421 
16422 fail:
16423  lua_error(L);
16424  return SWIG_arg;
16425 }
16426 
16427 
16428 static int _wrap_NodeIterator_Path(lua_State* L) {
16429  int argc;
16430  int argv[3]={
16431  1,2,3
16432  };
16433 
16434  argc = lua_gettop(L);
16435  if (argc == 1) {
16436  int _v;
16437  {
16438  void *ptr;
16439  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeIterator, 0)) {
16440  _v = 0;
16441  } else {
16442  _v = 1;
16443  }
16444  }
16445  if (_v) {
16446  return _wrap_NodeIterator_Path__SWIG_1(L);
16447  }
16448  }
16449  if (argc == 2) {
16450  int _v;
16451  {
16452  void *ptr;
16453  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeIterator, 0)) {
16454  _v = 0;
16455  } else {
16456  _v = 1;
16457  }
16458  }
16459  if (_v) {
16460  {
16461  _v = SWIG_lua_isnilstring(L,argv[1]) && (lua_rawlen(L,argv[1])==1);
16462  }
16463  if (_v) {
16464  return _wrap_NodeIterator_Path__SWIG_0(L);
16465  }
16466  }
16467  }
16468 
16469  lua_pushstring(L,"Wrong arguments for overloaded function 'NodeIterator_Path'\n"
16470  " Possible C/C++ prototypes are:\n"
16471  " Mezzanine::XML::Node::Path(Mezzanine::Char8) const\n"
16472  " Mezzanine::XML::Node::Path() const\n");
16473  lua_error(L);return 0;
16474 }
16475 
16476 
16477 static int _wrap_NodeIterator_FirstElementByPath__SWIG_0(lua_State* L) {
16478  int SWIG_arg = 0;
16480  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
16481  Mezzanine::Char8 arg3 ;
16482  Mezzanine::XML::Node result;
16483 
16484  SWIG_check_num_args("Mezzanine::XML::Node::FirstElementByPath",3,3)
16485  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::FirstElementByPath",1,"Mezzanine::XML::NodeIterator const *");
16486  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::FirstElementByPath",2,"Mezzanine::Char8 const *");
16487  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::FirstElementByPath",3,"Mezzanine::Char8");
16488 
16489  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
16490  SWIG_fail_ptr("NodeIterator_FirstElementByPath",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
16491  }
16492 
16493  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
16494  arg3 = (lua_tostring(L, 3))[0];
16495  result = (*arg1)->FirstElementByPath((Mezzanine::Char8 const *)arg2,arg3);
16496  {
16497  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
16498  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
16499  }
16500  return SWIG_arg;
16501 
16502  if(0) SWIG_fail;
16503 
16504 fail:
16505  lua_error(L);
16506  return SWIG_arg;
16507 }
16508 
16509 
16510 static int _wrap_NodeIterator_FirstElementByPath__SWIG_1(lua_State* L) {
16511  int SWIG_arg = 0;
16513  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
16514  Mezzanine::XML::Node result;
16515 
16516  SWIG_check_num_args("Mezzanine::XML::Node::FirstElementByPath",2,2)
16517  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::FirstElementByPath",1,"Mezzanine::XML::NodeIterator const *");
16518  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::FirstElementByPath",2,"Mezzanine::Char8 const *");
16519 
16520  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
16521  SWIG_fail_ptr("NodeIterator_FirstElementByPath",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
16522  }
16523 
16524  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
16525  result = (*arg1)->FirstElementByPath((Mezzanine::Char8 const *)arg2);
16526  {
16527  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
16528  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
16529  }
16530  return SWIG_arg;
16531 
16532  if(0) SWIG_fail;
16533 
16534 fail:
16535  lua_error(L);
16536  return SWIG_arg;
16537 }
16538 
16539 
16540 static int _wrap_NodeIterator_FirstElementByPath(lua_State* L) {
16541  int argc;
16542  int argv[4]={
16543  1,2,3,4
16544  };
16545 
16546  argc = lua_gettop(L);
16547  if (argc == 2) {
16548  int _v;
16549  {
16550  void *ptr;
16551  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeIterator, 0)) {
16552  _v = 0;
16553  } else {
16554  _v = 1;
16555  }
16556  }
16557  if (_v) {
16558  {
16559  _v = SWIG_lua_isnilstring(L,argv[1]);
16560  }
16561  if (_v) {
16562  return _wrap_NodeIterator_FirstElementByPath__SWIG_1(L);
16563  }
16564  }
16565  }
16566  if (argc == 3) {
16567  int _v;
16568  {
16569  void *ptr;
16570  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeIterator, 0)) {
16571  _v = 0;
16572  } else {
16573  _v = 1;
16574  }
16575  }
16576  if (_v) {
16577  {
16578  _v = SWIG_lua_isnilstring(L,argv[1]);
16579  }
16580  if (_v) {
16581  {
16582  _v = SWIG_lua_isnilstring(L,argv[2]) && (lua_rawlen(L,argv[2])==1);
16583  }
16584  if (_v) {
16585  return _wrap_NodeIterator_FirstElementByPath__SWIG_0(L);
16586  }
16587  }
16588  }
16589  }
16590 
16591  lua_pushstring(L,"Wrong arguments for overloaded function 'NodeIterator_FirstElementByPath'\n"
16592  " Possible C/C++ prototypes are:\n"
16593  " Mezzanine::XML::Node::FirstElementByPath(Mezzanine::Char8 const *,Mezzanine::Char8) const\n"
16594  " Mezzanine::XML::Node::FirstElementByPath(Mezzanine::Char8 const *) const\n");
16595  lua_error(L);return 0;
16596 }
16597 
16598 
16599 static int _wrap_NodeIterator_Traverse(lua_State* L) {
16600  int SWIG_arg = 0;
16602  Mezzanine::XML::TreeWalker *arg2 = 0 ;
16603  bool result;
16604 
16605  SWIG_check_num_args("Mezzanine::XML::Node::Traverse",2,2)
16606  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Traverse",1,"Mezzanine::XML::NodeIterator *");
16607  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::Traverse",2,"Mezzanine::XML::TreeWalker &");
16608 
16609  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
16610  SWIG_fail_ptr("NodeIterator_Traverse",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
16611  }
16612 
16613 
16614  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__TreeWalker,0))){
16615  SWIG_fail_ptr("NodeIterator_Traverse",2,SWIGTYPE_p_Mezzanine__XML__TreeWalker);
16616  }
16617 
16618  result = (bool)(*arg1)->Traverse(*arg2);
16619  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
16620  return SWIG_arg;
16621 
16622  if(0) SWIG_fail;
16623 
16624 fail:
16625  lua_error(L);
16626  return SWIG_arg;
16627 }
16628 
16629 
16630 static int _wrap_NodeIterator_FindSingleNode__SWIG_0(lua_State* L) {
16631  int SWIG_arg = 0;
16633  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
16636 
16637  SWIG_check_num_args("Mezzanine::XML::Node::FindSingleNode",3,3)
16638  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::FindSingleNode",1,"Mezzanine::XML::NodeIterator const *");
16639  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::FindSingleNode",2,"Mezzanine::Char8 const *");
16640  if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::FindSingleNode",3,"Mezzanine::XML::XPathVariableSet *");
16641 
16642  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
16643  SWIG_fail_ptr("NodeIterator_FindSingleNode",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
16644  }
16645 
16646  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
16647 
16648  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__XML__XPathVariableSet,0))){
16649  SWIG_fail_ptr("NodeIterator_FindSingleNode",3,SWIGTYPE_p_Mezzanine__XML__XPathVariableSet);
16650  }
16651 
16652  result = (*arg1)->FindSingleNode((Mezzanine::Char8 const *)arg2,arg3);
16653  {
16655  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__XPathNode,1); SWIG_arg++;
16656  }
16657  return SWIG_arg;
16658 
16659  if(0) SWIG_fail;
16660 
16661 fail:
16662  lua_error(L);
16663  return SWIG_arg;
16664 }
16665 
16666 
16667 static int _wrap_NodeIterator_FindSingleNode__SWIG_1(lua_State* L) {
16668  int SWIG_arg = 0;
16670  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
16672 
16673  SWIG_check_num_args("Mezzanine::XML::Node::FindSingleNode",2,2)
16674  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::FindSingleNode",1,"Mezzanine::XML::NodeIterator const *");
16675  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::FindSingleNode",2,"Mezzanine::Char8 const *");
16676 
16677  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
16678  SWIG_fail_ptr("NodeIterator_FindSingleNode",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
16679  }
16680 
16681  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
16682  result = (*arg1)->FindSingleNode((Mezzanine::Char8 const *)arg2);
16683  {
16685  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__XPathNode,1); SWIG_arg++;
16686  }
16687  return SWIG_arg;
16688 
16689  if(0) SWIG_fail;
16690 
16691 fail:
16692  lua_error(L);
16693  return SWIG_arg;
16694 }
16695 
16696 
16697 static int _wrap_NodeIterator_FindSingleNode__SWIG_2(lua_State* L) {
16698  int SWIG_arg = 0;
16700  Mezzanine::XML::XPathQuery *arg2 = 0 ;
16702 
16703  SWIG_check_num_args("Mezzanine::XML::Node::FindSingleNode",2,2)
16704  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::FindSingleNode",1,"Mezzanine::XML::NodeIterator const *");
16705  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::FindSingleNode",2,"Mezzanine::XML::XPathQuery const &");
16706 
16707  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
16708  SWIG_fail_ptr("NodeIterator_FindSingleNode",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
16709  }
16710 
16711 
16712  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__XPathQuery,0))){
16713  SWIG_fail_ptr("NodeIterator_FindSingleNode",2,SWIGTYPE_p_Mezzanine__XML__XPathQuery);
16714  }
16715 
16716  result = (*arg1)->FindSingleNode((Mezzanine::XML::XPathQuery const &)*arg2);
16717  {
16719  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__XPathNode,1); SWIG_arg++;
16720  }
16721  return SWIG_arg;
16722 
16723  if(0) SWIG_fail;
16724 
16725 fail:
16726  lua_error(L);
16727  return SWIG_arg;
16728 }
16729 
16730 
16731 static int _wrap_NodeIterator_FindSingleNode(lua_State* L) {
16732  int argc;
16733  int argv[4]={
16734  1,2,3,4
16735  };
16736 
16737  argc = lua_gettop(L);
16738  if (argc == 2) {
16739  int _v;
16740  {
16741  void *ptr;
16742  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeIterator, 0)) {
16743  _v = 0;
16744  } else {
16745  _v = 1;
16746  }
16747  }
16748  if (_v) {
16749  {
16750  void *ptr;
16751  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__XPathQuery, 0)) {
16752  _v = 0;
16753  } else {
16754  _v = 1;
16755  }
16756  }
16757  if (_v) {
16758  return _wrap_NodeIterator_FindSingleNode__SWIG_2(L);
16759  }
16760  }
16761  }
16762  if (argc == 2) {
16763  int _v;
16764  {
16765  void *ptr;
16766  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeIterator, 0)) {
16767  _v = 0;
16768  } else {
16769  _v = 1;
16770  }
16771  }
16772  if (_v) {
16773  {
16774  _v = SWIG_lua_isnilstring(L,argv[1]);
16775  }
16776  if (_v) {
16777  return _wrap_NodeIterator_FindSingleNode__SWIG_1(L);
16778  }
16779  }
16780  }
16781  if (argc == 3) {
16782  int _v;
16783  {
16784  void *ptr;
16785  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeIterator, 0)) {
16786  _v = 0;
16787  } else {
16788  _v = 1;
16789  }
16790  }
16791  if (_v) {
16792  {
16793  _v = SWIG_lua_isnilstring(L,argv[1]);
16794  }
16795  if (_v) {
16796  {
16797  void *ptr;
16798  if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__XPathVariableSet, 0)) {
16799  _v = 0;
16800  } else {
16801  _v = 1;
16802  }
16803  }
16804  if (_v) {
16805  return _wrap_NodeIterator_FindSingleNode__SWIG_0(L);
16806  }
16807  }
16808  }
16809  }
16810 
16811  lua_pushstring(L,"Wrong arguments for overloaded function 'NodeIterator_FindSingleNode'\n"
16812  " Possible C/C++ prototypes are:\n"
16813  " Mezzanine::XML::Node::FindSingleNode(Mezzanine::Char8 const *,Mezzanine::XML::XPathVariableSet *) const\n"
16814  " Mezzanine::XML::Node::FindSingleNode(Mezzanine::Char8 const *) const\n"
16815  " Mezzanine::XML::Node::FindSingleNode(Mezzanine::XML::XPathQuery const &) const\n");
16816  lua_error(L);return 0;
16817 }
16818 
16819 
16820 static int _wrap_NodeIterator_FindNodes__SWIG_0(lua_State* L) {
16821  int SWIG_arg = 0;
16823  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
16826 
16827  SWIG_check_num_args("Mezzanine::XML::Node::FindNodes",3,3)
16828  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::FindNodes",1,"Mezzanine::XML::NodeIterator const *");
16829  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::FindNodes",2,"Mezzanine::Char8 const *");
16830  if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::FindNodes",3,"Mezzanine::XML::XPathVariableSet *");
16831 
16832  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
16833  SWIG_fail_ptr("NodeIterator_FindNodes",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
16834  }
16835 
16836  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
16837 
16838  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__XML__XPathVariableSet,0))){
16839  SWIG_fail_ptr("NodeIterator_FindNodes",3,SWIGTYPE_p_Mezzanine__XML__XPathVariableSet);
16840  }
16841 
16842  result = (*arg1)->FindNodes((Mezzanine::Char8 const *)arg2,arg3);
16843  {
16845  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__XPathNodeSet,1); SWIG_arg++;
16846  }
16847  return SWIG_arg;
16848 
16849  if(0) SWIG_fail;
16850 
16851 fail:
16852  lua_error(L);
16853  return SWIG_arg;
16854 }
16855 
16856 
16857 static int _wrap_NodeIterator_FindNodes__SWIG_1(lua_State* L) {
16858  int SWIG_arg = 0;
16860  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
16862 
16863  SWIG_check_num_args("Mezzanine::XML::Node::FindNodes",2,2)
16864  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::FindNodes",1,"Mezzanine::XML::NodeIterator const *");
16865  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::FindNodes",2,"Mezzanine::Char8 const *");
16866 
16867  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
16868  SWIG_fail_ptr("NodeIterator_FindNodes",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
16869  }
16870 
16871  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
16872  result = (*arg1)->FindNodes((Mezzanine::Char8 const *)arg2);
16873  {
16875  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__XPathNodeSet,1); SWIG_arg++;
16876  }
16877  return SWIG_arg;
16878 
16879  if(0) SWIG_fail;
16880 
16881 fail:
16882  lua_error(L);
16883  return SWIG_arg;
16884 }
16885 
16886 
16887 static int _wrap_NodeIterator_FindNodes__SWIG_2(lua_State* L) {
16888  int SWIG_arg = 0;
16890  Mezzanine::XML::XPathQuery *arg2 = 0 ;
16892 
16893  SWIG_check_num_args("Mezzanine::XML::Node::FindNodes",2,2)
16894  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::FindNodes",1,"Mezzanine::XML::NodeIterator const *");
16895  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::FindNodes",2,"Mezzanine::XML::XPathQuery const &");
16896 
16897  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
16898  SWIG_fail_ptr("NodeIterator_FindNodes",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
16899  }
16900 
16901 
16902  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__XPathQuery,0))){
16903  SWIG_fail_ptr("NodeIterator_FindNodes",2,SWIGTYPE_p_Mezzanine__XML__XPathQuery);
16904  }
16905 
16906  result = (*arg1)->FindNodes((Mezzanine::XML::XPathQuery const &)*arg2);
16907  {
16909  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__XPathNodeSet,1); SWIG_arg++;
16910  }
16911  return SWIG_arg;
16912 
16913  if(0) SWIG_fail;
16914 
16915 fail:
16916  lua_error(L);
16917  return SWIG_arg;
16918 }
16919 
16920 
16921 static int _wrap_NodeIterator_FindNodes(lua_State* L) {
16922  int argc;
16923  int argv[4]={
16924  1,2,3,4
16925  };
16926 
16927  argc = lua_gettop(L);
16928  if (argc == 2) {
16929  int _v;
16930  {
16931  void *ptr;
16932  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeIterator, 0)) {
16933  _v = 0;
16934  } else {
16935  _v = 1;
16936  }
16937  }
16938  if (_v) {
16939  {
16940  void *ptr;
16941  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__XPathQuery, 0)) {
16942  _v = 0;
16943  } else {
16944  _v = 1;
16945  }
16946  }
16947  if (_v) {
16948  return _wrap_NodeIterator_FindNodes__SWIG_2(L);
16949  }
16950  }
16951  }
16952  if (argc == 2) {
16953  int _v;
16954  {
16955  void *ptr;
16956  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeIterator, 0)) {
16957  _v = 0;
16958  } else {
16959  _v = 1;
16960  }
16961  }
16962  if (_v) {
16963  {
16964  _v = SWIG_lua_isnilstring(L,argv[1]);
16965  }
16966  if (_v) {
16967  return _wrap_NodeIterator_FindNodes__SWIG_1(L);
16968  }
16969  }
16970  }
16971  if (argc == 3) {
16972  int _v;
16973  {
16974  void *ptr;
16975  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeIterator, 0)) {
16976  _v = 0;
16977  } else {
16978  _v = 1;
16979  }
16980  }
16981  if (_v) {
16982  {
16983  _v = SWIG_lua_isnilstring(L,argv[1]);
16984  }
16985  if (_v) {
16986  {
16987  void *ptr;
16988  if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__XPathVariableSet, 0)) {
16989  _v = 0;
16990  } else {
16991  _v = 1;
16992  }
16993  }
16994  if (_v) {
16995  return _wrap_NodeIterator_FindNodes__SWIG_0(L);
16996  }
16997  }
16998  }
16999  }
17000 
17001  lua_pushstring(L,"Wrong arguments for overloaded function 'NodeIterator_FindNodes'\n"
17002  " Possible C/C++ prototypes are:\n"
17003  " Mezzanine::XML::Node::FindNodes(Mezzanine::Char8 const *,Mezzanine::XML::XPathVariableSet *) const\n"
17004  " Mezzanine::XML::Node::FindNodes(Mezzanine::Char8 const *) const\n"
17005  " Mezzanine::XML::Node::FindNodes(Mezzanine::XML::XPathQuery const &) const\n");
17006  lua_error(L);return 0;
17007 }
17008 
17009 
17010 static int _wrap_NodeIterator_Print__SWIG_0(lua_State* L) {
17011  int SWIG_arg = 0;
17013  Mezzanine::XML::Writer *arg2 = 0 ;
17014  Mezzanine::Char8 *arg3 = (Mezzanine::Char8 *) 0 ;
17015  unsigned int arg4 ;
17017  unsigned int arg6 ;
17018 
17019  SWIG_check_num_args("Mezzanine::XML::Node::Print",6,6)
17020  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Print",1,"Mezzanine::XML::NodeIterator const *");
17021  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::Print",2,"Mezzanine::XML::Writer &");
17022  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::Print",3,"Mezzanine::Char8 const *");
17023  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::XML::Node::Print",4,"unsigned int");
17024  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::XML::Node::Print",5,"Mezzanine::XML::Encoding");
17025  if(!lua_isnumber(L,6)) SWIG_fail_arg("Mezzanine::XML::Node::Print",6,"unsigned int");
17026 
17027  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
17028  SWIG_fail_ptr("NodeIterator_Print",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
17029  }
17030 
17031 
17032  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Writer,0))){
17033  SWIG_fail_ptr("NodeIterator_Print",2,SWIGTYPE_p_Mezzanine__XML__Writer);
17034  }
17035 
17036  arg3 = (Mezzanine::Char8 *)lua_tostring(L, 3);
17037  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
17038  arg4 = (unsigned int)lua_tonumber(L, 4);
17039  arg5 = (Mezzanine::XML::Encoding)(int)lua_tonumber(L, 5);
17040  SWIG_contract_assert((lua_tonumber(L,6)>=0),"number must not be negative")
17041  arg6 = (unsigned int)lua_tonumber(L, 6);
17042  (*arg1)->Print(*arg2,(Mezzanine::Char8 const *)arg3,arg4,arg5,arg6);
17043 
17044  return SWIG_arg;
17045 
17046  if(0) SWIG_fail;
17047 
17048 fail:
17049  lua_error(L);
17050  return SWIG_arg;
17051 }
17052 
17053 
17054 static int _wrap_NodeIterator_Print__SWIG_1(lua_State* L) {
17055  int SWIG_arg = 0;
17057  Mezzanine::XML::Writer *arg2 = 0 ;
17058  Mezzanine::Char8 *arg3 = (Mezzanine::Char8 *) 0 ;
17059  unsigned int arg4 ;
17061 
17062  SWIG_check_num_args("Mezzanine::XML::Node::Print",5,5)
17063  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Print",1,"Mezzanine::XML::NodeIterator const *");
17064  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::Print",2,"Mezzanine::XML::Writer &");
17065  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::Print",3,"Mezzanine::Char8 const *");
17066  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::XML::Node::Print",4,"unsigned int");
17067  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::XML::Node::Print",5,"Mezzanine::XML::Encoding");
17068 
17069  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
17070  SWIG_fail_ptr("NodeIterator_Print",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
17071  }
17072 
17073 
17074  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Writer,0))){
17075  SWIG_fail_ptr("NodeIterator_Print",2,SWIGTYPE_p_Mezzanine__XML__Writer);
17076  }
17077 
17078  arg3 = (Mezzanine::Char8 *)lua_tostring(L, 3);
17079  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
17080  arg4 = (unsigned int)lua_tonumber(L, 4);
17081  arg5 = (Mezzanine::XML::Encoding)(int)lua_tonumber(L, 5);
17082  (*arg1)->Print(*arg2,(Mezzanine::Char8 const *)arg3,arg4,arg5);
17083 
17084  return SWIG_arg;
17085 
17086  if(0) SWIG_fail;
17087 
17088 fail:
17089  lua_error(L);
17090  return SWIG_arg;
17091 }
17092 
17093 
17094 static int _wrap_NodeIterator_Print__SWIG_2(lua_State* L) {
17095  int SWIG_arg = 0;
17097  Mezzanine::XML::Writer *arg2 = 0 ;
17098  Mezzanine::Char8 *arg3 = (Mezzanine::Char8 *) 0 ;
17099  unsigned int arg4 ;
17100 
17101  SWIG_check_num_args("Mezzanine::XML::Node::Print",4,4)
17102  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Print",1,"Mezzanine::XML::NodeIterator const *");
17103  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::Print",2,"Mezzanine::XML::Writer &");
17104  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::Print",3,"Mezzanine::Char8 const *");
17105  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::XML::Node::Print",4,"unsigned int");
17106 
17107  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
17108  SWIG_fail_ptr("NodeIterator_Print",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
17109  }
17110 
17111 
17112  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Writer,0))){
17113  SWIG_fail_ptr("NodeIterator_Print",2,SWIGTYPE_p_Mezzanine__XML__Writer);
17114  }
17115 
17116  arg3 = (Mezzanine::Char8 *)lua_tostring(L, 3);
17117  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
17118  arg4 = (unsigned int)lua_tonumber(L, 4);
17119  (*arg1)->Print(*arg2,(Mezzanine::Char8 const *)arg3,arg4);
17120 
17121  return SWIG_arg;
17122 
17123  if(0) SWIG_fail;
17124 
17125 fail:
17126  lua_error(L);
17127  return SWIG_arg;
17128 }
17129 
17130 
17131 static int _wrap_NodeIterator_Print__SWIG_3(lua_State* L) {
17132  int SWIG_arg = 0;
17134  Mezzanine::XML::Writer *arg2 = 0 ;
17135  Mezzanine::Char8 *arg3 = (Mezzanine::Char8 *) 0 ;
17136 
17137  SWIG_check_num_args("Mezzanine::XML::Node::Print",3,3)
17138  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Print",1,"Mezzanine::XML::NodeIterator const *");
17139  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::Print",2,"Mezzanine::XML::Writer &");
17140  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::Print",3,"Mezzanine::Char8 const *");
17141 
17142  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
17143  SWIG_fail_ptr("NodeIterator_Print",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
17144  }
17145 
17146 
17147  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Writer,0))){
17148  SWIG_fail_ptr("NodeIterator_Print",2,SWIGTYPE_p_Mezzanine__XML__Writer);
17149  }
17150 
17151  arg3 = (Mezzanine::Char8 *)lua_tostring(L, 3);
17152  (*arg1)->Print(*arg2,(Mezzanine::Char8 const *)arg3);
17153 
17154  return SWIG_arg;
17155 
17156  if(0) SWIG_fail;
17157 
17158 fail:
17159  lua_error(L);
17160  return SWIG_arg;
17161 }
17162 
17163 
17164 static int _wrap_NodeIterator_Print__SWIG_4(lua_State* L) {
17165  int SWIG_arg = 0;
17167  Mezzanine::XML::Writer *arg2 = 0 ;
17168 
17169  SWIG_check_num_args("Mezzanine::XML::Node::Print",2,2)
17170  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Print",1,"Mezzanine::XML::NodeIterator const *");
17171  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::Print",2,"Mezzanine::XML::Writer &");
17172 
17173  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
17174  SWIG_fail_ptr("NodeIterator_Print",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
17175  }
17176 
17177 
17178  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Writer,0))){
17179  SWIG_fail_ptr("NodeIterator_Print",2,SWIGTYPE_p_Mezzanine__XML__Writer);
17180  }
17181 
17182  (*arg1)->Print(*arg2);
17183 
17184  return SWIG_arg;
17185 
17186  if(0) SWIG_fail;
17187 
17188 fail:
17189  lua_error(L);
17190  return SWIG_arg;
17191 }
17192 
17193 
17194 static int _wrap_NodeIterator_Print__SWIG_5(lua_State* L) {
17195  int SWIG_arg = 0;
17197  std::basic_ostream< char,std::char_traits< char > > *arg2 = 0 ;
17198  Mezzanine::Char8 *arg3 = (Mezzanine::Char8 *) 0 ;
17199  unsigned int arg4 ;
17201  unsigned int arg6 ;
17202 
17203  SWIG_check_num_args("Mezzanine::XML::Node::Print",6,6)
17204  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Print",1,"Mezzanine::XML::NodeIterator const *");
17205  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::Print",2,"std::basic_ostream< char,std::char_traits< char > > &");
17206  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::Print",3,"Mezzanine::Char8 const *");
17207  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::XML::Node::Print",4,"unsigned int");
17208  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::XML::Node::Print",5,"Mezzanine::XML::Encoding");
17209  if(!lua_isnumber(L,6)) SWIG_fail_arg("Mezzanine::XML::Node::Print",6,"unsigned int");
17210 
17211  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
17212  SWIG_fail_ptr("NodeIterator_Print",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
17213  }
17214 
17215 
17216  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,0))){
17217  SWIG_fail_ptr("NodeIterator_Print",2,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t);
17218  }
17219 
17220  arg3 = (Mezzanine::Char8 *)lua_tostring(L, 3);
17221  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
17222  arg4 = (unsigned int)lua_tonumber(L, 4);
17223  arg5 = (Mezzanine::XML::Encoding)(int)lua_tonumber(L, 5);
17224  SWIG_contract_assert((lua_tonumber(L,6)>=0),"number must not be negative")
17225  arg6 = (unsigned int)lua_tonumber(L, 6);
17226  (*arg1)->Print(*arg2,(Mezzanine::Char8 const *)arg3,arg4,arg5,arg6);
17227 
17228  return SWIG_arg;
17229 
17230  if(0) SWIG_fail;
17231 
17232 fail:
17233  lua_error(L);
17234  return SWIG_arg;
17235 }
17236 
17237 
17238 static int _wrap_NodeIterator_Print__SWIG_6(lua_State* L) {
17239  int SWIG_arg = 0;
17241  std::basic_ostream< char,std::char_traits< char > > *arg2 = 0 ;
17242  Mezzanine::Char8 *arg3 = (Mezzanine::Char8 *) 0 ;
17243  unsigned int arg4 ;
17245 
17246  SWIG_check_num_args("Mezzanine::XML::Node::Print",5,5)
17247  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Print",1,"Mezzanine::XML::NodeIterator const *");
17248  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::Print",2,"std::basic_ostream< char,std::char_traits< char > > &");
17249  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::Print",3,"Mezzanine::Char8 const *");
17250  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::XML::Node::Print",4,"unsigned int");
17251  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::XML::Node::Print",5,"Mezzanine::XML::Encoding");
17252 
17253  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
17254  SWIG_fail_ptr("NodeIterator_Print",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
17255  }
17256 
17257 
17258  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,0))){
17259  SWIG_fail_ptr("NodeIterator_Print",2,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t);
17260  }
17261 
17262  arg3 = (Mezzanine::Char8 *)lua_tostring(L, 3);
17263  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
17264  arg4 = (unsigned int)lua_tonumber(L, 4);
17265  arg5 = (Mezzanine::XML::Encoding)(int)lua_tonumber(L, 5);
17266  (*arg1)->Print(*arg2,(Mezzanine::Char8 const *)arg3,arg4,arg5);
17267 
17268  return SWIG_arg;
17269 
17270  if(0) SWIG_fail;
17271 
17272 fail:
17273  lua_error(L);
17274  return SWIG_arg;
17275 }
17276 
17277 
17278 static int _wrap_NodeIterator_Print__SWIG_7(lua_State* L) {
17279  int SWIG_arg = 0;
17281  std::basic_ostream< char,std::char_traits< char > > *arg2 = 0 ;
17282  Mezzanine::Char8 *arg3 = (Mezzanine::Char8 *) 0 ;
17283  unsigned int arg4 ;
17284 
17285  SWIG_check_num_args("Mezzanine::XML::Node::Print",4,4)
17286  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Print",1,"Mezzanine::XML::NodeIterator const *");
17287  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::Print",2,"std::basic_ostream< char,std::char_traits< char > > &");
17288  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::Print",3,"Mezzanine::Char8 const *");
17289  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::XML::Node::Print",4,"unsigned int");
17290 
17291  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
17292  SWIG_fail_ptr("NodeIterator_Print",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
17293  }
17294 
17295 
17296  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,0))){
17297  SWIG_fail_ptr("NodeIterator_Print",2,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t);
17298  }
17299 
17300  arg3 = (Mezzanine::Char8 *)lua_tostring(L, 3);
17301  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
17302  arg4 = (unsigned int)lua_tonumber(L, 4);
17303  (*arg1)->Print(*arg2,(Mezzanine::Char8 const *)arg3,arg4);
17304 
17305  return SWIG_arg;
17306 
17307  if(0) SWIG_fail;
17308 
17309 fail:
17310  lua_error(L);
17311  return SWIG_arg;
17312 }
17313 
17314 
17315 static int _wrap_NodeIterator_Print__SWIG_8(lua_State* L) {
17316  int SWIG_arg = 0;
17318  std::basic_ostream< char,std::char_traits< char > > *arg2 = 0 ;
17319  Mezzanine::Char8 *arg3 = (Mezzanine::Char8 *) 0 ;
17320 
17321  SWIG_check_num_args("Mezzanine::XML::Node::Print",3,3)
17322  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Print",1,"Mezzanine::XML::NodeIterator const *");
17323  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::Print",2,"std::basic_ostream< char,std::char_traits< char > > &");
17324  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::Print",3,"Mezzanine::Char8 const *");
17325 
17326  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
17327  SWIG_fail_ptr("NodeIterator_Print",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
17328  }
17329 
17330 
17331  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,0))){
17332  SWIG_fail_ptr("NodeIterator_Print",2,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t);
17333  }
17334 
17335  arg3 = (Mezzanine::Char8 *)lua_tostring(L, 3);
17336  (*arg1)->Print(*arg2,(Mezzanine::Char8 const *)arg3);
17337 
17338  return SWIG_arg;
17339 
17340  if(0) SWIG_fail;
17341 
17342 fail:
17343  lua_error(L);
17344  return SWIG_arg;
17345 }
17346 
17347 
17348 static int _wrap_NodeIterator_Print__SWIG_9(lua_State* L) {
17349  int SWIG_arg = 0;
17351  std::basic_ostream< char,std::char_traits< char > > *arg2 = 0 ;
17352 
17353  SWIG_check_num_args("Mezzanine::XML::Node::Print",2,2)
17354  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Print",1,"Mezzanine::XML::NodeIterator const *");
17355  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::Print",2,"std::basic_ostream< char,std::char_traits< char > > &");
17356 
17357  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
17358  SWIG_fail_ptr("NodeIterator_Print",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
17359  }
17360 
17361 
17362  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,0))){
17363  SWIG_fail_ptr("NodeIterator_Print",2,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t);
17364  }
17365 
17366  (*arg1)->Print(*arg2);
17367 
17368  return SWIG_arg;
17369 
17370  if(0) SWIG_fail;
17371 
17372 fail:
17373  lua_error(L);
17374  return SWIG_arg;
17375 }
17376 
17377 
17378 static int _wrap_NodeIterator_Print__SWIG_10(lua_State* L) {
17379  int SWIG_arg = 0;
17381  std::basic_ostream< wchar_t,std::char_traits< wchar_t > > *arg2 = 0 ;
17382  Mezzanine::Char8 *arg3 = (Mezzanine::Char8 *) 0 ;
17383  unsigned int arg4 ;
17384  unsigned int arg5 ;
17385 
17386  SWIG_check_num_args("Mezzanine::XML::Node::Print",5,5)
17387  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Print",1,"Mezzanine::XML::NodeIterator const *");
17388  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::Print",2,"std::basic_ostream< wchar_t,std::char_traits< wchar_t > > &");
17389  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::Print",3,"Mezzanine::Char8 const *");
17390  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::XML::Node::Print",4,"unsigned int");
17391  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::XML::Node::Print",5,"unsigned int");
17392 
17393  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
17394  SWIG_fail_ptr("NodeIterator_Print",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
17395  }
17396 
17397 
17398  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__basic_ostreamT_wchar_t_std__char_traitsT_wchar_t_t_t,0))){
17399  SWIG_fail_ptr("NodeIterator_Print",2,SWIGTYPE_p_std__basic_ostreamT_wchar_t_std__char_traitsT_wchar_t_t_t);
17400  }
17401 
17402  arg3 = (Mezzanine::Char8 *)lua_tostring(L, 3);
17403  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
17404  arg4 = (unsigned int)lua_tonumber(L, 4);
17405  SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative")
17406  arg5 = (unsigned int)lua_tonumber(L, 5);
17407  (*arg1)->Print(*arg2,(Mezzanine::Char8 const *)arg3,arg4,arg5);
17408 
17409  return SWIG_arg;
17410 
17411  if(0) SWIG_fail;
17412 
17413 fail:
17414  lua_error(L);
17415  return SWIG_arg;
17416 }
17417 
17418 
17419 static int _wrap_NodeIterator_Print__SWIG_11(lua_State* L) {
17420  int SWIG_arg = 0;
17422  std::basic_ostream< wchar_t,std::char_traits< wchar_t > > *arg2 = 0 ;
17423  Mezzanine::Char8 *arg3 = (Mezzanine::Char8 *) 0 ;
17424  unsigned int arg4 ;
17425 
17426  SWIG_check_num_args("Mezzanine::XML::Node::Print",4,4)
17427  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Print",1,"Mezzanine::XML::NodeIterator const *");
17428  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::Print",2,"std::basic_ostream< wchar_t,std::char_traits< wchar_t > > &");
17429  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::Print",3,"Mezzanine::Char8 const *");
17430  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::XML::Node::Print",4,"unsigned int");
17431 
17432  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
17433  SWIG_fail_ptr("NodeIterator_Print",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
17434  }
17435 
17436 
17437  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__basic_ostreamT_wchar_t_std__char_traitsT_wchar_t_t_t,0))){
17438  SWIG_fail_ptr("NodeIterator_Print",2,SWIGTYPE_p_std__basic_ostreamT_wchar_t_std__char_traitsT_wchar_t_t_t);
17439  }
17440 
17441  arg3 = (Mezzanine::Char8 *)lua_tostring(L, 3);
17442  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
17443  arg4 = (unsigned int)lua_tonumber(L, 4);
17444  (*arg1)->Print(*arg2,(Mezzanine::Char8 const *)arg3,arg4);
17445 
17446  return SWIG_arg;
17447 
17448  if(0) SWIG_fail;
17449 
17450 fail:
17451  lua_error(L);
17452  return SWIG_arg;
17453 }
17454 
17455 
17456 static int _wrap_NodeIterator_Print__SWIG_12(lua_State* L) {
17457  int SWIG_arg = 0;
17459  std::basic_ostream< wchar_t,std::char_traits< wchar_t > > *arg2 = 0 ;
17460  Mezzanine::Char8 *arg3 = (Mezzanine::Char8 *) 0 ;
17461 
17462  SWIG_check_num_args("Mezzanine::XML::Node::Print",3,3)
17463  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Print",1,"Mezzanine::XML::NodeIterator const *");
17464  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::Print",2,"std::basic_ostream< wchar_t,std::char_traits< wchar_t > > &");
17465  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::Print",3,"Mezzanine::Char8 const *");
17466 
17467  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
17468  SWIG_fail_ptr("NodeIterator_Print",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
17469  }
17470 
17471 
17472  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__basic_ostreamT_wchar_t_std__char_traitsT_wchar_t_t_t,0))){
17473  SWIG_fail_ptr("NodeIterator_Print",2,SWIGTYPE_p_std__basic_ostreamT_wchar_t_std__char_traitsT_wchar_t_t_t);
17474  }
17475 
17476  arg3 = (Mezzanine::Char8 *)lua_tostring(L, 3);
17477  (*arg1)->Print(*arg2,(Mezzanine::Char8 const *)arg3);
17478 
17479  return SWIG_arg;
17480 
17481  if(0) SWIG_fail;
17482 
17483 fail:
17484  lua_error(L);
17485  return SWIG_arg;
17486 }
17487 
17488 
17489 static int _wrap_NodeIterator_Print__SWIG_13(lua_State* L) {
17490  int SWIG_arg = 0;
17492  std::basic_ostream< wchar_t,std::char_traits< wchar_t > > *arg2 = 0 ;
17493 
17494  SWIG_check_num_args("Mezzanine::XML::Node::Print",2,2)
17495  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Print",1,"Mezzanine::XML::NodeIterator const *");
17496  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::Print",2,"std::basic_ostream< wchar_t,std::char_traits< wchar_t > > &");
17497 
17498  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
17499  SWIG_fail_ptr("NodeIterator_Print",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
17500  }
17501 
17502 
17503  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__basic_ostreamT_wchar_t_std__char_traitsT_wchar_t_t_t,0))){
17504  SWIG_fail_ptr("NodeIterator_Print",2,SWIGTYPE_p_std__basic_ostreamT_wchar_t_std__char_traitsT_wchar_t_t_t);
17505  }
17506 
17507  (*arg1)->Print(*arg2);
17508 
17509  return SWIG_arg;
17510 
17511  if(0) SWIG_fail;
17512 
17513 fail:
17514  lua_error(L);
17515  return SWIG_arg;
17516 }
17517 
17518 
17519 static int _wrap_NodeIterator_Print(lua_State* L) {
17520  int argc;
17521  int argv[7]={
17522  1,2,3,4,5,6,7
17523  };
17524 
17525  argc = lua_gettop(L);
17526  if (argc == 2) {
17527  int _v;
17528  {
17529  void *ptr;
17530  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeIterator, 0)) {
17531  _v = 0;
17532  } else {
17533  _v = 1;
17534  }
17535  }
17536  if (_v) {
17537  {
17538  void *ptr;
17539  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Writer, 0)) {
17540  _v = 0;
17541  } else {
17542  _v = 1;
17543  }
17544  }
17545  if (_v) {
17546  return _wrap_NodeIterator_Print__SWIG_4(L);
17547  }
17548  }
17549  }
17550  if (argc == 2) {
17551  int _v;
17552  {
17553  void *ptr;
17554  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeIterator, 0)) {
17555  _v = 0;
17556  } else {
17557  _v = 1;
17558  }
17559  }
17560  if (_v) {
17561  {
17562  void *ptr;
17563  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0)) {
17564  _v = 0;
17565  } else {
17566  _v = 1;
17567  }
17568  }
17569  if (_v) {
17570  return _wrap_NodeIterator_Print__SWIG_9(L);
17571  }
17572  }
17573  }
17574  if (argc == 2) {
17575  int _v;
17576  {
17577  void *ptr;
17578  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeIterator, 0)) {
17579  _v = 0;
17580  } else {
17581  _v = 1;
17582  }
17583  }
17584  if (_v) {
17585  {
17586  void *ptr;
17587  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__basic_ostreamT_wchar_t_std__char_traitsT_wchar_t_t_t, 0)) {
17588  _v = 0;
17589  } else {
17590  _v = 1;
17591  }
17592  }
17593  if (_v) {
17594  return _wrap_NodeIterator_Print__SWIG_13(L);
17595  }
17596  }
17597  }
17598  if (argc == 3) {
17599  int _v;
17600  {
17601  void *ptr;
17602  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeIterator, 0)) {
17603  _v = 0;
17604  } else {
17605  _v = 1;
17606  }
17607  }
17608  if (_v) {
17609  {
17610  void *ptr;
17611  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Writer, 0)) {
17612  _v = 0;
17613  } else {
17614  _v = 1;
17615  }
17616  }
17617  if (_v) {
17618  {
17619  _v = SWIG_lua_isnilstring(L,argv[2]);
17620  }
17621  if (_v) {
17622  return _wrap_NodeIterator_Print__SWIG_3(L);
17623  }
17624  }
17625  }
17626  }
17627  if (argc == 3) {
17628  int _v;
17629  {
17630  void *ptr;
17631  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeIterator, 0)) {
17632  _v = 0;
17633  } else {
17634  _v = 1;
17635  }
17636  }
17637  if (_v) {
17638  {
17639  void *ptr;
17640  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__basic_ostreamT_wchar_t_std__char_traitsT_wchar_t_t_t, 0)) {
17641  _v = 0;
17642  } else {
17643  _v = 1;
17644  }
17645  }
17646  if (_v) {
17647  {
17648  _v = SWIG_lua_isnilstring(L,argv[2]);
17649  }
17650  if (_v) {
17651  return _wrap_NodeIterator_Print__SWIG_12(L);
17652  }
17653  }
17654  }
17655  }
17656  if (argc == 3) {
17657  int _v;
17658  {
17659  void *ptr;
17660  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeIterator, 0)) {
17661  _v = 0;
17662  } else {
17663  _v = 1;
17664  }
17665  }
17666  if (_v) {
17667  {
17668  void *ptr;
17669  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0)) {
17670  _v = 0;
17671  } else {
17672  _v = 1;
17673  }
17674  }
17675  if (_v) {
17676  {
17677  _v = SWIG_lua_isnilstring(L,argv[2]);
17678  }
17679  if (_v) {
17680  return _wrap_NodeIterator_Print__SWIG_8(L);
17681  }
17682  }
17683  }
17684  }
17685  if (argc == 4) {
17686  int _v;
17687  {
17688  void *ptr;
17689  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeIterator, 0)) {
17690  _v = 0;
17691  } else {
17692  _v = 1;
17693  }
17694  }
17695  if (_v) {
17696  {
17697  void *ptr;
17698  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__basic_ostreamT_wchar_t_std__char_traitsT_wchar_t_t_t, 0)) {
17699  _v = 0;
17700  } else {
17701  _v = 1;
17702  }
17703  }
17704  if (_v) {
17705  {
17706  _v = SWIG_lua_isnilstring(L,argv[2]);
17707  }
17708  if (_v) {
17709  {
17710  _v = lua_isnumber(L,argv[3]);
17711  }
17712  if (_v) {
17713  return _wrap_NodeIterator_Print__SWIG_11(L);
17714  }
17715  }
17716  }
17717  }
17718  }
17719  if (argc == 4) {
17720  int _v;
17721  {
17722  void *ptr;
17723  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeIterator, 0)) {
17724  _v = 0;
17725  } else {
17726  _v = 1;
17727  }
17728  }
17729  if (_v) {
17730  {
17731  void *ptr;
17732  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Writer, 0)) {
17733  _v = 0;
17734  } else {
17735  _v = 1;
17736  }
17737  }
17738  if (_v) {
17739  {
17740  _v = SWIG_lua_isnilstring(L,argv[2]);
17741  }
17742  if (_v) {
17743  {
17744  _v = lua_isnumber(L,argv[3]);
17745  }
17746  if (_v) {
17747  return _wrap_NodeIterator_Print__SWIG_2(L);
17748  }
17749  }
17750  }
17751  }
17752  }
17753  if (argc == 4) {
17754  int _v;
17755  {
17756  void *ptr;
17757  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeIterator, 0)) {
17758  _v = 0;
17759  } else {
17760  _v = 1;
17761  }
17762  }
17763  if (_v) {
17764  {
17765  void *ptr;
17766  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0)) {
17767  _v = 0;
17768  } else {
17769  _v = 1;
17770  }
17771  }
17772  if (_v) {
17773  {
17774  _v = SWIG_lua_isnilstring(L,argv[2]);
17775  }
17776  if (_v) {
17777  {
17778  _v = lua_isnumber(L,argv[3]);
17779  }
17780  if (_v) {
17781  return _wrap_NodeIterator_Print__SWIG_7(L);
17782  }
17783  }
17784  }
17785  }
17786  }
17787  if (argc == 5) {
17788  int _v;
17789  {
17790  void *ptr;
17791  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeIterator, 0)) {
17792  _v = 0;
17793  } else {
17794  _v = 1;
17795  }
17796  }
17797  if (_v) {
17798  {
17799  void *ptr;
17800  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0)) {
17801  _v = 0;
17802  } else {
17803  _v = 1;
17804  }
17805  }
17806  if (_v) {
17807  {
17808  _v = SWIG_lua_isnilstring(L,argv[2]);
17809  }
17810  if (_v) {
17811  {
17812  _v = lua_isnumber(L,argv[3]);
17813  }
17814  if (_v) {
17815  {
17816  _v = lua_isnumber(L,argv[4]);
17817  }
17818  if (_v) {
17819  return _wrap_NodeIterator_Print__SWIG_6(L);
17820  }
17821  }
17822  }
17823  }
17824  }
17825  }
17826  if (argc == 5) {
17827  int _v;
17828  {
17829  void *ptr;
17830  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeIterator, 0)) {
17831  _v = 0;
17832  } else {
17833  _v = 1;
17834  }
17835  }
17836  if (_v) {
17837  {
17838  void *ptr;
17839  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Writer, 0)) {
17840  _v = 0;
17841  } else {
17842  _v = 1;
17843  }
17844  }
17845  if (_v) {
17846  {
17847  _v = SWIG_lua_isnilstring(L,argv[2]);
17848  }
17849  if (_v) {
17850  {
17851  _v = lua_isnumber(L,argv[3]);
17852  }
17853  if (_v) {
17854  {
17855  _v = lua_isnumber(L,argv[4]);
17856  }
17857  if (_v) {
17858  return _wrap_NodeIterator_Print__SWIG_1(L);
17859  }
17860  }
17861  }
17862  }
17863  }
17864  }
17865  if (argc == 5) {
17866  int _v;
17867  {
17868  void *ptr;
17869  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeIterator, 0)) {
17870  _v = 0;
17871  } else {
17872  _v = 1;
17873  }
17874  }
17875  if (_v) {
17876  {
17877  void *ptr;
17878  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__basic_ostreamT_wchar_t_std__char_traitsT_wchar_t_t_t, 0)) {
17879  _v = 0;
17880  } else {
17881  _v = 1;
17882  }
17883  }
17884  if (_v) {
17885  {
17886  _v = SWIG_lua_isnilstring(L,argv[2]);
17887  }
17888  if (_v) {
17889  {
17890  _v = lua_isnumber(L,argv[3]);
17891  }
17892  if (_v) {
17893  {
17894  _v = lua_isnumber(L,argv[4]);
17895  }
17896  if (_v) {
17897  return _wrap_NodeIterator_Print__SWIG_10(L);
17898  }
17899  }
17900  }
17901  }
17902  }
17903  }
17904  if (argc == 6) {
17905  int _v;
17906  {
17907  void *ptr;
17908  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeIterator, 0)) {
17909  _v = 0;
17910  } else {
17911  _v = 1;
17912  }
17913  }
17914  if (_v) {
17915  {
17916  void *ptr;
17917  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Writer, 0)) {
17918  _v = 0;
17919  } else {
17920  _v = 1;
17921  }
17922  }
17923  if (_v) {
17924  {
17925  _v = SWIG_lua_isnilstring(L,argv[2]);
17926  }
17927  if (_v) {
17928  {
17929  _v = lua_isnumber(L,argv[3]);
17930  }
17931  if (_v) {
17932  {
17933  _v = lua_isnumber(L,argv[4]);
17934  }
17935  if (_v) {
17936  {
17937  _v = lua_isnumber(L,argv[5]);
17938  }
17939  if (_v) {
17940  return _wrap_NodeIterator_Print__SWIG_0(L);
17941  }
17942  }
17943  }
17944  }
17945  }
17946  }
17947  }
17948  if (argc == 6) {
17949  int _v;
17950  {
17951  void *ptr;
17952  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeIterator, 0)) {
17953  _v = 0;
17954  } else {
17955  _v = 1;
17956  }
17957  }
17958  if (_v) {
17959  {
17960  void *ptr;
17961  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0)) {
17962  _v = 0;
17963  } else {
17964  _v = 1;
17965  }
17966  }
17967  if (_v) {
17968  {
17969  _v = SWIG_lua_isnilstring(L,argv[2]);
17970  }
17971  if (_v) {
17972  {
17973  _v = lua_isnumber(L,argv[3]);
17974  }
17975  if (_v) {
17976  {
17977  _v = lua_isnumber(L,argv[4]);
17978  }
17979  if (_v) {
17980  {
17981  _v = lua_isnumber(L,argv[5]);
17982  }
17983  if (_v) {
17984  return _wrap_NodeIterator_Print__SWIG_5(L);
17985  }
17986  }
17987  }
17988  }
17989  }
17990  }
17991  }
17992 
17993  lua_pushstring(L,"Wrong arguments for overloaded function 'NodeIterator_Print'\n"
17994  " Possible C/C++ prototypes are:\n"
17995  " Mezzanine::XML::Node::Print(Mezzanine::XML::Writer &,Mezzanine::Char8 const *,unsigned int,Mezzanine::XML::Encoding,unsigned int) const\n"
17996  " Mezzanine::XML::Node::Print(Mezzanine::XML::Writer &,Mezzanine::Char8 const *,unsigned int,Mezzanine::XML::Encoding) const\n"
17997  " Mezzanine::XML::Node::Print(Mezzanine::XML::Writer &,Mezzanine::Char8 const *,unsigned int) const\n"
17998  " Mezzanine::XML::Node::Print(Mezzanine::XML::Writer &,Mezzanine::Char8 const *) const\n"
17999  " Mezzanine::XML::Node::Print(Mezzanine::XML::Writer &) const\n"
18000  " Mezzanine::XML::Node::Print(std::basic_ostream< char,std::char_traits< char > > &,Mezzanine::Char8 const *,unsigned int,Mezzanine::XML::Encoding,unsigned int) const\n"
18001  " Mezzanine::XML::Node::Print(std::basic_ostream< char,std::char_traits< char > > &,Mezzanine::Char8 const *,unsigned int,Mezzanine::XML::Encoding) const\n"
18002  " Mezzanine::XML::Node::Print(std::basic_ostream< char,std::char_traits< char > > &,Mezzanine::Char8 const *,unsigned int) const\n"
18003  " Mezzanine::XML::Node::Print(std::basic_ostream< char,std::char_traits< char > > &,Mezzanine::Char8 const *) const\n"
18004  " Mezzanine::XML::Node::Print(std::basic_ostream< char,std::char_traits< char > > &) const\n"
18005  " Mezzanine::XML::Node::Print(std::basic_ostream< wchar_t,std::char_traits< wchar_t > > &,Mezzanine::Char8 const *,unsigned int,unsigned int) const\n"
18006  " Mezzanine::XML::Node::Print(std::basic_ostream< wchar_t,std::char_traits< wchar_t > > &,Mezzanine::Char8 const *,unsigned int) const\n"
18007  " Mezzanine::XML::Node::Print(std::basic_ostream< wchar_t,std::char_traits< wchar_t > > &,Mezzanine::Char8 const *) const\n"
18008  " Mezzanine::XML::Node::Print(std::basic_ostream< wchar_t,std::char_traits< wchar_t > > &) const\n");
18009  lua_error(L);return 0;
18010 }
18011 
18012 
18013 static int _wrap_NodeIterator_begin(lua_State* L) {
18014  int SWIG_arg = 0;
18017 
18018  SWIG_check_num_args("Mezzanine::XML::Node::begin",1,1)
18019  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::begin",1,"Mezzanine::XML::NodeIterator const *");
18020 
18021  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
18022  SWIG_fail_ptr("NodeIterator_begin",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
18023  }
18024 
18025  result = (*arg1)->begin();
18026  {
18028  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__NodeIterator,1); SWIG_arg++;
18029  }
18030  return SWIG_arg;
18031 
18032  if(0) SWIG_fail;
18033 
18034 fail:
18035  lua_error(L);
18036  return SWIG_arg;
18037 }
18038 
18039 
18040 static int _wrap_NodeIterator_end(lua_State* L) {
18041  int SWIG_arg = 0;
18044 
18045  SWIG_check_num_args("Mezzanine::XML::Node::end",1,1)
18046  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::end",1,"Mezzanine::XML::NodeIterator const *");
18047 
18048  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
18049  SWIG_fail_ptr("NodeIterator_end",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
18050  }
18051 
18052  result = (*arg1)->end();
18053  {
18055  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__NodeIterator,1); SWIG_arg++;
18056  }
18057  return SWIG_arg;
18058 
18059  if(0) SWIG_fail;
18060 
18061 fail:
18062  lua_error(L);
18063  return SWIG_arg;
18064 }
18065 
18066 
18067 static int _wrap_NodeIterator_attributes_begin(lua_State* L) {
18068  int SWIG_arg = 0;
18071 
18072  SWIG_check_num_args("Mezzanine::XML::Node::attributes_begin",1,1)
18073  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::attributes_begin",1,"Mezzanine::XML::NodeIterator const *");
18074 
18075  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
18076  SWIG_fail_ptr("NodeIterator_attributes_begin",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
18077  }
18078 
18079  result = (*arg1)->attributes_begin();
18080  {
18082  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__AttributeIterator,1); SWIG_arg++;
18083  }
18084  return SWIG_arg;
18085 
18086  if(0) SWIG_fail;
18087 
18088 fail:
18089  lua_error(L);
18090  return SWIG_arg;
18091 }
18092 
18093 
18094 static int _wrap_NodeIterator_attributes_end(lua_State* L) {
18095  int SWIG_arg = 0;
18098 
18099  SWIG_check_num_args("Mezzanine::XML::Node::attributes_end",1,1)
18100  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::attributes_end",1,"Mezzanine::XML::NodeIterator const *");
18101 
18102  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
18103  SWIG_fail_ptr("NodeIterator_attributes_end",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
18104  }
18105 
18106  result = (*arg1)->attributes_end();
18107  {
18109  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__AttributeIterator,1); SWIG_arg++;
18110  }
18111  return SWIG_arg;
18112 
18113  if(0) SWIG_fail;
18114 
18115 fail:
18116  lua_error(L);
18117  return SWIG_arg;
18118 }
18119 
18120 
18121 static int _wrap_NodeIterator_GetChildren__SWIG_0(lua_State* L) {
18122  int SWIG_arg = 0;
18124  SwigValueWrapper< Mezzanine::XML::ObjectRange< Mezzanine::XML::NodeIterator > > result;
18125 
18126  SWIG_check_num_args("Mezzanine::XML::Node::GetChildren",1,1)
18127  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::GetChildren",1,"Mezzanine::XML::NodeIterator const *");
18128 
18129  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
18130  SWIG_fail_ptr("NodeIterator_GetChildren",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
18131  }
18132 
18133  result = (*arg1)->GetChildren();
18134  {
18136  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__ObjectRangeT_Mezzanine__XML__NodeIterator_t,1); SWIG_arg++;
18137  }
18138  return SWIG_arg;
18139 
18140  if(0) SWIG_fail;
18141 
18142 fail:
18143  lua_error(L);
18144  return SWIG_arg;
18145 }
18146 
18147 
18148 static int _wrap_NodeIterator_GetChildren__SWIG_1(lua_State* L) {
18149  int SWIG_arg = 0;
18151  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
18152  SwigValueWrapper< Mezzanine::XML::ObjectRange< Mezzanine::XML::NamedNodeIterator > > result;
18153 
18154  SWIG_check_num_args("Mezzanine::XML::Node::GetChildren",2,2)
18155  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::GetChildren",1,"Mezzanine::XML::NodeIterator const *");
18156  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::GetChildren",2,"Mezzanine::Char8 const *");
18157 
18158  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
18159  SWIG_fail_ptr("NodeIterator_GetChildren",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
18160  }
18161 
18162  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
18163  result = (*arg1)->GetChildren((Mezzanine::Char8 const *)arg2);
18164  {
18166  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__ObjectRangeT_Mezzanine__XML__NamedNodeIterator_t,1); SWIG_arg++;
18167  }
18168  return SWIG_arg;
18169 
18170  if(0) SWIG_fail;
18171 
18172 fail:
18173  lua_error(L);
18174  return SWIG_arg;
18175 }
18176 
18177 
18178 static int _wrap_NodeIterator_GetChildren(lua_State* L) {
18179  int argc;
18180  int argv[3]={
18181  1,2,3
18182  };
18183 
18184  argc = lua_gettop(L);
18185  if (argc == 1) {
18186  int _v;
18187  {
18188  void *ptr;
18189  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeIterator, 0)) {
18190  _v = 0;
18191  } else {
18192  _v = 1;
18193  }
18194  }
18195  if (_v) {
18196  return _wrap_NodeIterator_GetChildren__SWIG_0(L);
18197  }
18198  }
18199  if (argc == 2) {
18200  int _v;
18201  {
18202  void *ptr;
18203  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeIterator, 0)) {
18204  _v = 0;
18205  } else {
18206  _v = 1;
18207  }
18208  }
18209  if (_v) {
18210  {
18211  _v = SWIG_lua_isnilstring(L,argv[1]);
18212  }
18213  if (_v) {
18214  return _wrap_NodeIterator_GetChildren__SWIG_1(L);
18215  }
18216  }
18217  }
18218 
18219  lua_pushstring(L,"Wrong arguments for overloaded function 'NodeIterator_GetChildren'\n"
18220  " Possible C/C++ prototypes are:\n"
18221  " Mezzanine::XML::Node::GetChildren() const\n"
18222  " Mezzanine::XML::Node::GetChildren(Mezzanine::Char8 const *) const\n");
18223  lua_error(L);return 0;
18224 }
18225 
18226 
18227 static int _wrap_NodeIterator_attributes(lua_State* L) {
18228  int SWIG_arg = 0;
18230  SwigValueWrapper< Mezzanine::XML::ObjectRange< Mezzanine::XML::AttributeIterator > > result;
18231 
18232  SWIG_check_num_args("Mezzanine::XML::Node::attributes",1,1)
18233  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::attributes",1,"Mezzanine::XML::NodeIterator const *");
18234 
18235  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
18236  SWIG_fail_ptr("NodeIterator_attributes",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
18237  }
18238 
18239  result = (*arg1)->attributes();
18240  {
18242  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__ObjectRangeT_Mezzanine__XML__AttributeIterator_t,1); SWIG_arg++;
18243  }
18244  return SWIG_arg;
18245 
18246  if(0) SWIG_fail;
18247 
18248 fail:
18249  lua_error(L);
18250  return SWIG_arg;
18251 }
18252 
18253 
18254 static int _wrap_NodeIterator_OffSetDebug(lua_State* L) {
18255  int SWIG_arg = 0;
18257  ptrdiff_t result;
18258 
18259  SWIG_check_num_args("Mezzanine::XML::Node::OffSetDebug",1,1)
18260  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::OffSetDebug",1,"Mezzanine::XML::NodeIterator const *");
18261 
18262  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
18263  SWIG_fail_ptr("NodeIterator_OffSetDebug",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
18264  }
18265 
18266  result = (*arg1)->OffSetDebug();
18267  {
18268  ptrdiff_t * resultptr = new ptrdiff_t((const ptrdiff_t &) result);
18269  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ptrdiff_t,1); SWIG_arg++;
18270  }
18271  return SWIG_arg;
18272 
18273  if(0) SWIG_fail;
18274 
18275 fail:
18276  lua_error(L);
18277  return SWIG_arg;
18278 }
18279 
18280 
18281 static int _wrap_NodeIterator_HashValue(lua_State* L) {
18282  int SWIG_arg = 0;
18284  size_t result;
18285 
18286  SWIG_check_num_args("Mezzanine::XML::Node::HashValue",1,1)
18287  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::HashValue",1,"Mezzanine::XML::NodeIterator const *");
18288 
18289  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
18290  SWIG_fail_ptr("NodeIterator_HashValue",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
18291  }
18292 
18293  result = (*arg1)->HashValue();
18294  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
18295  return SWIG_arg;
18296 
18297  if(0) SWIG_fail;
18298 
18299 fail:
18300  lua_error(L);
18301  return SWIG_arg;
18302 }
18303 
18304 
18305 static int _wrap_NodeIterator_InternalObject(lua_State* L) {
18306  int SWIG_arg = 0;
18308  Mezzanine::XML::NodeStruct *result = 0 ;
18309 
18310  SWIG_check_num_args("Mezzanine::XML::Node::InternalObject",1,1)
18311  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::InternalObject",1,"Mezzanine::XML::NodeIterator const *");
18312 
18313  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeIterator,0))){
18314  SWIG_fail_ptr("NodeIterator_InternalObject",1,SWIGTYPE_p_Mezzanine__XML__NodeIterator);
18315  }
18316 
18317  result = (Mezzanine::XML::NodeStruct *)(*arg1)->InternalObject();
18318  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__XML__NodeStruct,0); SWIG_arg++;
18319  return SWIG_arg;
18320 
18321  if(0) SWIG_fail;
18322 
18323 fail:
18324  lua_error(L);
18325  return SWIG_arg;
18326 }
18327 
18328 
18329 static void swig_delete_NodeIterator(void *obj) {
18331 delete arg1;
18332 }
18333 static swig_lua_method swig_Mezzanine_XML_NodeIterator_methods[] = {
18334  {"__eq", _wrap_NodeIterator___eq},
18335  {"__ref__", _wrap_NodeIterator___ref__},
18336  {"__deref__", _wrap_NodeIterator___deref__},
18337  {"__lt", _wrap_NodeIterator___lt},
18338  {"__le", _wrap_NodeIterator___le},
18339  {"Empty", _wrap_NodeIterator_Empty},
18340  {"Type", _wrap_NodeIterator_Type},
18341  {"Name", _wrap_NodeIterator_Name},
18342  {"Value", _wrap_NodeIterator_Value},
18343  {"GetFirstAttribute", _wrap_NodeIterator_GetFirstAttribute},
18344  {"GetLastAttribute", _wrap_NodeIterator_GetLastAttribute},
18345  {"GetFirstChild", _wrap_NodeIterator_GetFirstChild},
18346  {"GetLastChild", _wrap_NodeIterator_GetLastChild},
18347  {"GetNextSibling", _wrap_NodeIterator_GetNextSibling},
18348  {"GetPreviousSibling", _wrap_NodeIterator_GetPreviousSibling},
18349  {"GetParent", _wrap_NodeIterator_GetParent},
18350  {"GetRoot", _wrap_NodeIterator_GetRoot},
18351  {"GetText", _wrap_NodeIterator_GetText},
18352  {"GetChild", _wrap_NodeIterator_GetChild},
18353  {"GetAttribute", _wrap_NodeIterator_GetAttribute},
18354  {"GetChildValue", _wrap_NodeIterator_GetChildValue},
18355  {"SetName", _wrap_NodeIterator_SetName},
18356  {"SetValue", _wrap_NodeIterator_SetValue},
18357  {"AppendAttribute", _wrap_NodeIterator_AppendAttribute},
18358  {"PrependAttribute", _wrap_NodeIterator_PrependAttribute},
18359  {"InsertAttributeAfter", _wrap_NodeIterator_InsertAttributeAfter},
18360  {"InsertAttributeBefore", _wrap_NodeIterator_InsertAttributeBefore},
18361  {"AppendCopy", _wrap_NodeIterator_AppendCopy},
18362  {"PrependCopy", _wrap_NodeIterator_PrependCopy},
18363  {"InsertCopyAfter", _wrap_NodeIterator_InsertCopyAfter},
18364  {"InsertCopyBefore", _wrap_NodeIterator_InsertCopyBefore},
18365  {"AppendChild", _wrap_NodeIterator_AppendChild},
18366  {"PrependChild", _wrap_NodeIterator_PrependChild},
18367  {"InsertChildAfter", _wrap_NodeIterator_InsertChildAfter},
18368  {"InsertChildBefore", _wrap_NodeIterator_InsertChildBefore},
18369  {"RemoveAttribute", _wrap_NodeIterator_RemoveAttribute},
18370  {"RemoveChild", _wrap_NodeIterator_RemoveChild},
18371  {"FindChildbyAttribute", _wrap_NodeIterator_FindChildbyAttribute},
18372  {"Path", _wrap_NodeIterator_Path},
18373  {"FirstElementByPath", _wrap_NodeIterator_FirstElementByPath},
18374  {"Traverse", _wrap_NodeIterator_Traverse},
18375  {"FindSingleNode", _wrap_NodeIterator_FindSingleNode},
18376  {"FindNodes", _wrap_NodeIterator_FindNodes},
18377  {"Print", _wrap_NodeIterator_Print},
18378  {"begin", _wrap_NodeIterator_begin},
18379  {"end", _wrap_NodeIterator_end},
18380  {"attributes_begin", _wrap_NodeIterator_attributes_begin},
18381  {"attributes_end", _wrap_NodeIterator_attributes_end},
18382  {"GetChildren", _wrap_NodeIterator_GetChildren},
18383  {"attributes", _wrap_NodeIterator_attributes},
18384  {"OffSetDebug", _wrap_NodeIterator_OffSetDebug},
18385  {"HashValue", _wrap_NodeIterator_HashValue},
18386  {"InternalObject", _wrap_NodeIterator_InternalObject},
18387  {0,0}
18388 };
18389 static swig_lua_attribute swig_Mezzanine_XML_NodeIterator_attributes[] = {
18390  {0,0,0}
18391 };
18392 static swig_lua_class *swig_Mezzanine_XML_NodeIterator_bases[] = {0};
18393 static const char *swig_Mezzanine_XML_NodeIterator_base_names[] = {0};
18394 static swig_lua_class _wrap_class_Mezzanine_XML_NodeIterator = { "NodeIterator", &SWIGTYPE_p_Mezzanine__XML__NodeIterator,_wrap_new_NodeIterator, swig_delete_NodeIterator, swig_Mezzanine_XML_NodeIterator_methods, swig_Mezzanine_XML_NodeIterator_attributes, swig_Mezzanine_XML_NodeIterator_bases, swig_Mezzanine_XML_NodeIterator_base_names };
18395 
18396 static int _wrap_new_NamedNodeIterator__SWIG_0(lua_State* L) {
18397  int SWIG_arg = 0;
18398  Mezzanine::XML::NamedNodeIterator *result = 0 ;
18399 
18400  SWIG_check_num_args("Mezzanine::XML::NamedNodeIterator::NamedNodeIterator",0,0)
18401  result = (Mezzanine::XML::NamedNodeIterator *)new Mezzanine::XML::NamedNodeIterator();
18402  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,1); SWIG_arg++;
18403  return SWIG_arg;
18404 
18405  if(0) SWIG_fail;
18406 
18407 fail:
18408  lua_error(L);
18409  return SWIG_arg;
18410 }
18411 
18412 
18413 static int _wrap_new_NamedNodeIterator__SWIG_1(lua_State* L) {
18414  int SWIG_arg = 0;
18415  Mezzanine::XML::Node *arg1 = 0 ;
18416  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
18417  Mezzanine::XML::NamedNodeIterator *result = 0 ;
18418 
18419  SWIG_check_num_args("Mezzanine::XML::NamedNodeIterator::NamedNodeIterator",2,2)
18420  if(!lua_isuserdata(L,1)) SWIG_fail_arg("Mezzanine::XML::NamedNodeIterator::NamedNodeIterator",1,"Mezzanine::XML::Node const &");
18421  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::NamedNodeIterator::NamedNodeIterator",2,"Mezzanine::Char8 const *");
18422 
18423  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
18424  SWIG_fail_ptr("new_NamedNodeIterator",1,SWIGTYPE_p_Mezzanine__XML__Node);
18425  }
18426 
18427  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
18429  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,1); SWIG_arg++;
18430  return SWIG_arg;
18431 
18432  if(0) SWIG_fail;
18433 
18434 fail:
18435  lua_error(L);
18436  return SWIG_arg;
18437 }
18438 
18439 
18440 static int _wrap_new_NamedNodeIterator(lua_State* L) {
18441  int argc;
18442  int argv[3]={
18443  1,2,3
18444  };
18445 
18446  argc = lua_gettop(L);
18447  if (argc == 0) {
18448  return _wrap_new_NamedNodeIterator__SWIG_0(L);
18449  }
18450  if (argc == 2) {
18451  int _v;
18452  {
18453  void *ptr;
18454  if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
18455  _v = 0;
18456  } else {
18457  _v = 1;
18458  }
18459  }
18460  if (_v) {
18461  {
18462  _v = SWIG_lua_isnilstring(L,argv[1]);
18463  }
18464  if (_v) {
18465  return _wrap_new_NamedNodeIterator__SWIG_1(L);
18466  }
18467  }
18468  }
18469 
18470  lua_pushstring(L,"Wrong arguments for overloaded function 'new_NamedNodeIterator'\n"
18471  " Possible C/C++ prototypes are:\n"
18472  " Mezzanine::XML::NamedNodeIterator::NamedNodeIterator()\n"
18473  " Mezzanine::XML::NamedNodeIterator::NamedNodeIterator(Mezzanine::XML::Node const &,Mezzanine::Char8 const *)\n");
18474  lua_error(L);return 0;
18475 }
18476 
18477 
18478 static int _wrap_NamedNodeIterator___eq(lua_State* L) {
18479  int SWIG_arg = 0;
18482  bool result;
18483 
18484  SWIG_check_num_args("Mezzanine::XML::NamedNodeIterator::operator ==",2,2)
18485  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::NamedNodeIterator::operator ==",1,"Mezzanine::XML::NamedNodeIterator const *");
18486  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::NamedNodeIterator::operator ==",2,"Mezzanine::XML::NamedNodeIterator const &");
18487 
18488  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
18489  SWIG_fail_ptr("NamedNodeIterator___eq",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
18490  }
18491 
18492 
18493  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
18494  SWIG_fail_ptr("NamedNodeIterator___eq",2,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
18495  }
18496 
18497  result = (bool)((Mezzanine::XML::NamedNodeIterator const *)arg1)->operator ==((Mezzanine::XML::NamedNodeIterator const &)*arg2);
18498  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
18499  return SWIG_arg;
18500 
18501  if(0) SWIG_fail;
18502 
18503 fail:
18504  lua_error(L);
18505  return SWIG_arg;
18506 }
18507 
18508 
18509 static int _wrap_NamedNodeIterator___ref__(lua_State* L) {
18510  int SWIG_arg = 0;
18512  Mezzanine::XML::Node *result = 0 ;
18513 
18514  SWIG_check_num_args("Mezzanine::XML::NamedNodeIterator::operator *",1,1)
18515  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::NamedNodeIterator::operator *",1,"Mezzanine::XML::NamedNodeIterator const *");
18516 
18517  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
18518  SWIG_fail_ptr("NamedNodeIterator___ref__",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
18519  }
18520 
18521  result = (Mezzanine::XML::Node *) &((Mezzanine::XML::NamedNodeIterator const *)arg1)->operator *();
18522  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__XML__Node,0); SWIG_arg++;
18523  return SWIG_arg;
18524 
18525  if(0) SWIG_fail;
18526 
18527 fail:
18528  lua_error(L);
18529  return SWIG_arg;
18530 }
18531 
18532 
18533 static int _wrap_NamedNodeIterator___deref__(lua_State* L) {
18534  int SWIG_arg = 0;
18536  Mezzanine::XML::Node *result = 0 ;
18537 
18538  SWIG_check_num_args("Mezzanine::XML::NamedNodeIterator::operator ->",1,1)
18539  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::NamedNodeIterator::operator ->",1,"Mezzanine::XML::NamedNodeIterator const *");
18540 
18541  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
18542  SWIG_fail_ptr("NamedNodeIterator___deref__",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
18543  }
18544 
18545  result = (Mezzanine::XML::Node *)((Mezzanine::XML::NamedNodeIterator const *)arg1)->operator ->();
18546  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__XML__Node,0); SWIG_arg++;
18547  return SWIG_arg;
18548 
18549  if(0) SWIG_fail;
18550 
18551 fail:
18552  lua_error(L);
18553  return SWIG_arg;
18554 }
18555 
18556 
18557 static int _wrap_NamedNodeIterator___lt(lua_State* L) {
18558  int SWIG_arg = 0;
18560  Mezzanine::XML::Node *arg2 = 0 ;
18561  bool result;
18562 
18563  SWIG_check_num_args("Mezzanine::XML::Node::operator <",2,2)
18564  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::operator <",1,"Mezzanine::XML::NamedNodeIterator const *");
18565  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::operator <",2,"Mezzanine::XML::Node const &");
18566 
18567  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
18568  SWIG_fail_ptr("NamedNodeIterator___lt",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
18569  }
18570 
18571 
18572  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Node,0))){
18573  SWIG_fail_ptr("NamedNodeIterator___lt",2,SWIGTYPE_p_Mezzanine__XML__Node);
18574  }
18575 
18576  result = (bool)(*arg1)->operator <((Mezzanine::XML::Node const &)*arg2);
18577  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
18578  return SWIG_arg;
18579 
18580  if(0) SWIG_fail;
18581 
18582 fail:
18583  lua_error(L);
18584  return SWIG_arg;
18585 }
18586 
18587 
18588 static int _wrap_NamedNodeIterator___le(lua_State* L) {
18589  int SWIG_arg = 0;
18591  Mezzanine::XML::Node *arg2 = 0 ;
18592  bool result;
18593 
18594  SWIG_check_num_args("Mezzanine::XML::Node::operator <=",2,2)
18595  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::operator <=",1,"Mezzanine::XML::NamedNodeIterator const *");
18596  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::operator <=",2,"Mezzanine::XML::Node const &");
18597 
18598  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
18599  SWIG_fail_ptr("NamedNodeIterator___le",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
18600  }
18601 
18602 
18603  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Node,0))){
18604  SWIG_fail_ptr("NamedNodeIterator___le",2,SWIGTYPE_p_Mezzanine__XML__Node);
18605  }
18606 
18607  result = (bool)(*arg1)->operator <=((Mezzanine::XML::Node const &)*arg2);
18608  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
18609  return SWIG_arg;
18610 
18611  if(0) SWIG_fail;
18612 
18613 fail:
18614  lua_error(L);
18615  return SWIG_arg;
18616 }
18617 
18618 
18619 static int _wrap_NamedNodeIterator_Empty(lua_State* L) {
18620  int SWIG_arg = 0;
18622  bool result;
18623 
18624  SWIG_check_num_args("Mezzanine::XML::Node::Empty",1,1)
18625  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Empty",1,"Mezzanine::XML::NamedNodeIterator const *");
18626 
18627  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
18628  SWIG_fail_ptr("NamedNodeIterator_Empty",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
18629  }
18630 
18631  result = (bool)(*arg1)->Empty();
18632  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
18633  return SWIG_arg;
18634 
18635  if(0) SWIG_fail;
18636 
18637 fail:
18638  lua_error(L);
18639  return SWIG_arg;
18640 }
18641 
18642 
18643 static int _wrap_NamedNodeIterator_Type(lua_State* L) {
18644  int SWIG_arg = 0;
18646  Mezzanine::XML::NodeType result;
18647 
18648  SWIG_check_num_args("Mezzanine::XML::Node::Type",1,1)
18649  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Type",1,"Mezzanine::XML::NamedNodeIterator const *");
18650 
18651  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
18652  SWIG_fail_ptr("NamedNodeIterator_Type",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
18653  }
18654 
18655  result = (Mezzanine::XML::NodeType)(*arg1)->Type();
18656  lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++;
18657  return SWIG_arg;
18658 
18659  if(0) SWIG_fail;
18660 
18661 fail:
18662  lua_error(L);
18663  return SWIG_arg;
18664 }
18665 
18666 
18667 static int _wrap_NamedNodeIterator_Name(lua_State* L) {
18668  int SWIG_arg = 0;
18670  Mezzanine::Char8 *result = 0 ;
18671 
18672  SWIG_check_num_args("Mezzanine::XML::Node::Name",1,1)
18673  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Name",1,"Mezzanine::XML::NamedNodeIterator const *");
18674 
18675  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
18676  SWIG_fail_ptr("NamedNodeIterator_Name",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
18677  }
18678 
18679  result = (Mezzanine::Char8 *)(*arg1)->Name();
18680  lua_pushstring(L,(const char *)result); SWIG_arg++;
18681  return SWIG_arg;
18682 
18683  if(0) SWIG_fail;
18684 
18685 fail:
18686  lua_error(L);
18687  return SWIG_arg;
18688 }
18689 
18690 
18691 static int _wrap_NamedNodeIterator_Value(lua_State* L) {
18692  int SWIG_arg = 0;
18694  Mezzanine::Char8 *result = 0 ;
18695 
18696  SWIG_check_num_args("Mezzanine::XML::Node::Value",1,1)
18697  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Value",1,"Mezzanine::XML::NamedNodeIterator const *");
18698 
18699  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
18700  SWIG_fail_ptr("NamedNodeIterator_Value",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
18701  }
18702 
18703  result = (Mezzanine::Char8 *)(*arg1)->Value();
18704  lua_pushstring(L,(const char *)result); SWIG_arg++;
18705  return SWIG_arg;
18706 
18707  if(0) SWIG_fail;
18708 
18709 fail:
18710  lua_error(L);
18711  return SWIG_arg;
18712 }
18713 
18714 
18715 static int _wrap_NamedNodeIterator_GetFirstAttribute(lua_State* L) {
18716  int SWIG_arg = 0;
18719 
18720  SWIG_check_num_args("Mezzanine::XML::Node::GetFirstAttribute",1,1)
18721  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::GetFirstAttribute",1,"Mezzanine::XML::NamedNodeIterator const *");
18722 
18723  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
18724  SWIG_fail_ptr("NamedNodeIterator_GetFirstAttribute",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
18725  }
18726 
18727  result = (*arg1)->GetFirstAttribute();
18728  {
18730  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Attribute,1); SWIG_arg++;
18731  }
18732  return SWIG_arg;
18733 
18734  if(0) SWIG_fail;
18735 
18736 fail:
18737  lua_error(L);
18738  return SWIG_arg;
18739 }
18740 
18741 
18742 static int _wrap_NamedNodeIterator_GetLastAttribute(lua_State* L) {
18743  int SWIG_arg = 0;
18746 
18747  SWIG_check_num_args("Mezzanine::XML::Node::GetLastAttribute",1,1)
18748  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::GetLastAttribute",1,"Mezzanine::XML::NamedNodeIterator const *");
18749 
18750  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
18751  SWIG_fail_ptr("NamedNodeIterator_GetLastAttribute",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
18752  }
18753 
18754  result = (*arg1)->GetLastAttribute();
18755  {
18757  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Attribute,1); SWIG_arg++;
18758  }
18759  return SWIG_arg;
18760 
18761  if(0) SWIG_fail;
18762 
18763 fail:
18764  lua_error(L);
18765  return SWIG_arg;
18766 }
18767 
18768 
18769 static int _wrap_NamedNodeIterator_GetFirstChild(lua_State* L) {
18770  int SWIG_arg = 0;
18772  Mezzanine::XML::Node result;
18773 
18774  SWIG_check_num_args("Mezzanine::XML::Node::GetFirstChild",1,1)
18775  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::GetFirstChild",1,"Mezzanine::XML::NamedNodeIterator const *");
18776 
18777  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
18778  SWIG_fail_ptr("NamedNodeIterator_GetFirstChild",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
18779  }
18780 
18781  result = (*arg1)->GetFirstChild();
18782  {
18783  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
18784  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
18785  }
18786  return SWIG_arg;
18787 
18788  if(0) SWIG_fail;
18789 
18790 fail:
18791  lua_error(L);
18792  return SWIG_arg;
18793 }
18794 
18795 
18796 static int _wrap_NamedNodeIterator_GetLastChild(lua_State* L) {
18797  int SWIG_arg = 0;
18799  Mezzanine::XML::Node result;
18800 
18801  SWIG_check_num_args("Mezzanine::XML::Node::GetLastChild",1,1)
18802  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::GetLastChild",1,"Mezzanine::XML::NamedNodeIterator const *");
18803 
18804  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
18805  SWIG_fail_ptr("NamedNodeIterator_GetLastChild",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
18806  }
18807 
18808  result = (*arg1)->GetLastChild();
18809  {
18810  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
18811  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
18812  }
18813  return SWIG_arg;
18814 
18815  if(0) SWIG_fail;
18816 
18817 fail:
18818  lua_error(L);
18819  return SWIG_arg;
18820 }
18821 
18822 
18823 static int _wrap_NamedNodeIterator_GetNextSibling__SWIG_0(lua_State* L) {
18824  int SWIG_arg = 0;
18826  Mezzanine::XML::Node result;
18827 
18828  SWIG_check_num_args("Mezzanine::XML::Node::GetNextSibling",1,1)
18829  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::GetNextSibling",1,"Mezzanine::XML::NamedNodeIterator const *");
18830 
18831  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
18832  SWIG_fail_ptr("NamedNodeIterator_GetNextSibling",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
18833  }
18834 
18835  result = (*arg1)->GetNextSibling();
18836  {
18837  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
18838  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
18839  }
18840  return SWIG_arg;
18841 
18842  if(0) SWIG_fail;
18843 
18844 fail:
18845  lua_error(L);
18846  return SWIG_arg;
18847 }
18848 
18849 
18850 static int _wrap_NamedNodeIterator_GetNextSibling__SWIG_1(lua_State* L) {
18851  int SWIG_arg = 0;
18853  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
18854  Mezzanine::XML::Node result;
18855 
18856  SWIG_check_num_args("Mezzanine::XML::Node::GetNextSibling",2,2)
18857  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::GetNextSibling",1,"Mezzanine::XML::NamedNodeIterator const *");
18858  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::GetNextSibling",2,"Mezzanine::Char8 const *");
18859 
18860  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
18861  SWIG_fail_ptr("NamedNodeIterator_GetNextSibling",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
18862  }
18863 
18864  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
18865  result = (*arg1)->GetNextSibling((Mezzanine::Char8 const *)arg2);
18866  {
18867  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
18868  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
18869  }
18870  return SWIG_arg;
18871 
18872  if(0) SWIG_fail;
18873 
18874 fail:
18875  lua_error(L);
18876  return SWIG_arg;
18877 }
18878 
18879 
18880 static int _wrap_NamedNodeIterator_GetNextSibling(lua_State* L) {
18881  int argc;
18882  int argv[3]={
18883  1,2,3
18884  };
18885 
18886  argc = lua_gettop(L);
18887  if (argc == 1) {
18888  int _v;
18889  {
18890  void *ptr;
18891  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator, 0)) {
18892  _v = 0;
18893  } else {
18894  _v = 1;
18895  }
18896  }
18897  if (_v) {
18898  return _wrap_NamedNodeIterator_GetNextSibling__SWIG_0(L);
18899  }
18900  }
18901  if (argc == 2) {
18902  int _v;
18903  {
18904  void *ptr;
18905  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator, 0)) {
18906  _v = 0;
18907  } else {
18908  _v = 1;
18909  }
18910  }
18911  if (_v) {
18912  {
18913  _v = SWIG_lua_isnilstring(L,argv[1]);
18914  }
18915  if (_v) {
18916  return _wrap_NamedNodeIterator_GetNextSibling__SWIG_1(L);
18917  }
18918  }
18919  }
18920 
18921  lua_pushstring(L,"Wrong arguments for overloaded function 'NamedNodeIterator_GetNextSibling'\n"
18922  " Possible C/C++ prototypes are:\n"
18923  " Mezzanine::XML::Node::GetNextSibling() const\n"
18924  " Mezzanine::XML::Node::GetNextSibling(Mezzanine::Char8 const *) const\n");
18925  lua_error(L);return 0;
18926 }
18927 
18928 
18929 static int _wrap_NamedNodeIterator_GetPreviousSibling__SWIG_0(lua_State* L) {
18930  int SWIG_arg = 0;
18932  Mezzanine::XML::Node result;
18933 
18934  SWIG_check_num_args("Mezzanine::XML::Node::GetPreviousSibling",1,1)
18935  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::GetPreviousSibling",1,"Mezzanine::XML::NamedNodeIterator const *");
18936 
18937  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
18938  SWIG_fail_ptr("NamedNodeIterator_GetPreviousSibling",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
18939  }
18940 
18941  result = (*arg1)->GetPreviousSibling();
18942  {
18943  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
18944  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
18945  }
18946  return SWIG_arg;
18947 
18948  if(0) SWIG_fail;
18949 
18950 fail:
18951  lua_error(L);
18952  return SWIG_arg;
18953 }
18954 
18955 
18956 static int _wrap_NamedNodeIterator_GetPreviousSibling__SWIG_1(lua_State* L) {
18957  int SWIG_arg = 0;
18959  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
18960  Mezzanine::XML::Node result;
18961 
18962  SWIG_check_num_args("Mezzanine::XML::Node::GetPreviousSibling",2,2)
18963  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::GetPreviousSibling",1,"Mezzanine::XML::NamedNodeIterator const *");
18964  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::GetPreviousSibling",2,"Mezzanine::Char8 const *");
18965 
18966  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
18967  SWIG_fail_ptr("NamedNodeIterator_GetPreviousSibling",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
18968  }
18969 
18970  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
18971  result = (*arg1)->GetPreviousSibling((Mezzanine::Char8 const *)arg2);
18972  {
18973  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
18974  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
18975  }
18976  return SWIG_arg;
18977 
18978  if(0) SWIG_fail;
18979 
18980 fail:
18981  lua_error(L);
18982  return SWIG_arg;
18983 }
18984 
18985 
18986 static int _wrap_NamedNodeIterator_GetPreviousSibling(lua_State* L) {
18987  int argc;
18988  int argv[3]={
18989  1,2,3
18990  };
18991 
18992  argc = lua_gettop(L);
18993  if (argc == 1) {
18994  int _v;
18995  {
18996  void *ptr;
18997  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator, 0)) {
18998  _v = 0;
18999  } else {
19000  _v = 1;
19001  }
19002  }
19003  if (_v) {
19004  return _wrap_NamedNodeIterator_GetPreviousSibling__SWIG_0(L);
19005  }
19006  }
19007  if (argc == 2) {
19008  int _v;
19009  {
19010  void *ptr;
19011  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator, 0)) {
19012  _v = 0;
19013  } else {
19014  _v = 1;
19015  }
19016  }
19017  if (_v) {
19018  {
19019  _v = SWIG_lua_isnilstring(L,argv[1]);
19020  }
19021  if (_v) {
19022  return _wrap_NamedNodeIterator_GetPreviousSibling__SWIG_1(L);
19023  }
19024  }
19025  }
19026 
19027  lua_pushstring(L,"Wrong arguments for overloaded function 'NamedNodeIterator_GetPreviousSibling'\n"
19028  " Possible C/C++ prototypes are:\n"
19029  " Mezzanine::XML::Node::GetPreviousSibling() const\n"
19030  " Mezzanine::XML::Node::GetPreviousSibling(Mezzanine::Char8 const *) const\n");
19031  lua_error(L);return 0;
19032 }
19033 
19034 
19035 static int _wrap_NamedNodeIterator_GetParent(lua_State* L) {
19036  int SWIG_arg = 0;
19038  Mezzanine::XML::Node result;
19039 
19040  SWIG_check_num_args("Mezzanine::XML::Node::GetParent",1,1)
19041  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::GetParent",1,"Mezzanine::XML::NamedNodeIterator const *");
19042 
19043  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
19044  SWIG_fail_ptr("NamedNodeIterator_GetParent",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
19045  }
19046 
19047  result = (*arg1)->GetParent();
19048  {
19049  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
19050  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
19051  }
19052  return SWIG_arg;
19053 
19054  if(0) SWIG_fail;
19055 
19056 fail:
19057  lua_error(L);
19058  return SWIG_arg;
19059 }
19060 
19061 
19062 static int _wrap_NamedNodeIterator_GetRoot(lua_State* L) {
19063  int SWIG_arg = 0;
19065  Mezzanine::XML::Node result;
19066 
19067  SWIG_check_num_args("Mezzanine::XML::Node::GetRoot",1,1)
19068  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::GetRoot",1,"Mezzanine::XML::NamedNodeIterator const *");
19069 
19070  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
19071  SWIG_fail_ptr("NamedNodeIterator_GetRoot",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
19072  }
19073 
19074  result = (*arg1)->GetRoot();
19075  {
19076  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
19077  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
19078  }
19079  return SWIG_arg;
19080 
19081  if(0) SWIG_fail;
19082 
19083 fail:
19084  lua_error(L);
19085  return SWIG_arg;
19086 }
19087 
19088 
19089 static int _wrap_NamedNodeIterator_GetText(lua_State* L) {
19090  int SWIG_arg = 0;
19092  Mezzanine::XML::NodeText result;
19093 
19094  SWIG_check_num_args("Mezzanine::XML::Node::GetText",1,1)
19095  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::GetText",1,"Mezzanine::XML::NamedNodeIterator const *");
19096 
19097  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
19098  SWIG_fail_ptr("NamedNodeIterator_GetText",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
19099  }
19100 
19101  result = (*arg1)->GetText();
19102  {
19104  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__NodeText,1); SWIG_arg++;
19105  }
19106  return SWIG_arg;
19107 
19108  if(0) SWIG_fail;
19109 
19110 fail:
19111  lua_error(L);
19112  return SWIG_arg;
19113 }
19114 
19115 
19116 static int _wrap_NamedNodeIterator_GetChild(lua_State* L) {
19117  int SWIG_arg = 0;
19119  Mezzanine::String *arg2 = 0 ;
19120  Mezzanine::String temp2 ;
19121  Mezzanine::XML::Node result;
19122 
19123  SWIG_check_num_args("Mezzanine::XML::Node::GetChild",2,2)
19124  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::GetChild",1,"Mezzanine::XML::NamedNodeIterator const *");
19125  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::GetChild",2,"Mezzanine::String const &");
19126 
19127  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
19128  SWIG_fail_ptr("NamedNodeIterator_GetChild",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
19129  }
19130 
19131  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
19132  result = (*arg1)->GetChild((Mezzanine::String const &)*arg2);
19133  {
19134  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
19135  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
19136  }
19137  return SWIG_arg;
19138 
19139  if(0) SWIG_fail;
19140 
19141 fail:
19142  lua_error(L);
19143  return SWIG_arg;
19144 }
19145 
19146 
19147 static int _wrap_NamedNodeIterator_GetAttribute(lua_State* L) {
19148  int SWIG_arg = 0;
19150  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
19152 
19153  SWIG_check_num_args("Mezzanine::XML::Node::GetAttribute",2,2)
19154  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::GetAttribute",1,"Mezzanine::XML::NamedNodeIterator const *");
19155  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::GetAttribute",2,"Mezzanine::Char8 const *");
19156 
19157  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
19158  SWIG_fail_ptr("NamedNodeIterator_GetAttribute",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
19159  }
19160 
19161  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
19162  result = (*arg1)->GetAttribute((Mezzanine::Char8 const *)arg2);
19163  {
19165  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Attribute,1); SWIG_arg++;
19166  }
19167  return SWIG_arg;
19168 
19169  if(0) SWIG_fail;
19170 
19171 fail:
19172  lua_error(L);
19173  return SWIG_arg;
19174 }
19175 
19176 
19177 static int _wrap_NamedNodeIterator_GetChildValue__SWIG_0(lua_State* L) {
19178  int SWIG_arg = 0;
19180  Mezzanine::Char8 *result = 0 ;
19181 
19182  SWIG_check_num_args("Mezzanine::XML::Node::GetChildValue",1,1)
19183  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::GetChildValue",1,"Mezzanine::XML::NamedNodeIterator const *");
19184 
19185  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
19186  SWIG_fail_ptr("NamedNodeIterator_GetChildValue",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
19187  }
19188 
19189  result = (Mezzanine::Char8 *)(*arg1)->GetChildValue();
19190  lua_pushstring(L,(const char *)result); SWIG_arg++;
19191  return SWIG_arg;
19192 
19193  if(0) SWIG_fail;
19194 
19195 fail:
19196  lua_error(L);
19197  return SWIG_arg;
19198 }
19199 
19200 
19201 static int _wrap_NamedNodeIterator_GetChildValue__SWIG_1(lua_State* L) {
19202  int SWIG_arg = 0;
19204  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
19205  Mezzanine::Char8 *result = 0 ;
19206 
19207  SWIG_check_num_args("Mezzanine::XML::Node::GetChildValue",2,2)
19208  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::GetChildValue",1,"Mezzanine::XML::NamedNodeIterator const *");
19209  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::GetChildValue",2,"Mezzanine::Char8 const *");
19210 
19211  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
19212  SWIG_fail_ptr("NamedNodeIterator_GetChildValue",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
19213  }
19214 
19215  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
19216  result = (Mezzanine::Char8 *)(*arg1)->GetChildValue((Mezzanine::Char8 const *)arg2);
19217  lua_pushstring(L,(const char *)result); SWIG_arg++;
19218  return SWIG_arg;
19219 
19220  if(0) SWIG_fail;
19221 
19222 fail:
19223  lua_error(L);
19224  return SWIG_arg;
19225 }
19226 
19227 
19228 static int _wrap_NamedNodeIterator_GetChildValue(lua_State* L) {
19229  int argc;
19230  int argv[3]={
19231  1,2,3
19232  };
19233 
19234  argc = lua_gettop(L);
19235  if (argc == 1) {
19236  int _v;
19237  {
19238  void *ptr;
19239  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator, 0)) {
19240  _v = 0;
19241  } else {
19242  _v = 1;
19243  }
19244  }
19245  if (_v) {
19246  return _wrap_NamedNodeIterator_GetChildValue__SWIG_0(L);
19247  }
19248  }
19249  if (argc == 2) {
19250  int _v;
19251  {
19252  void *ptr;
19253  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator, 0)) {
19254  _v = 0;
19255  } else {
19256  _v = 1;
19257  }
19258  }
19259  if (_v) {
19260  {
19261  _v = SWIG_lua_isnilstring(L,argv[1]);
19262  }
19263  if (_v) {
19264  return _wrap_NamedNodeIterator_GetChildValue__SWIG_1(L);
19265  }
19266  }
19267  }
19268 
19269  lua_pushstring(L,"Wrong arguments for overloaded function 'NamedNodeIterator_GetChildValue'\n"
19270  " Possible C/C++ prototypes are:\n"
19271  " Mezzanine::XML::Node::GetChildValue() const\n"
19272  " Mezzanine::XML::Node::GetChildValue(Mezzanine::Char8 const *) const\n");
19273  lua_error(L);return 0;
19274 }
19275 
19276 
19277 static int _wrap_NamedNodeIterator_SetName(lua_State* L) {
19278  int SWIG_arg = 0;
19280  Mezzanine::String *arg2 = 0 ;
19281  Mezzanine::String temp2 ;
19282  bool result;
19283 
19284  SWIG_check_num_args("Mezzanine::XML::Node::SetName",2,2)
19285  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::SetName",1,"Mezzanine::XML::NamedNodeIterator *");
19286  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::SetName",2,"Mezzanine::String const &");
19287 
19288  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
19289  SWIG_fail_ptr("NamedNodeIterator_SetName",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
19290  }
19291 
19292  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
19293  result = (bool)(*arg1)->SetName((Mezzanine::String const &)*arg2);
19294  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
19295  return SWIG_arg;
19296 
19297  if(0) SWIG_fail;
19298 
19299 fail:
19300  lua_error(L);
19301  return SWIG_arg;
19302 }
19303 
19304 
19305 static int _wrap_NamedNodeIterator_SetValue(lua_State* L) {
19306  int SWIG_arg = 0;
19308  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
19309  bool result;
19310 
19311  SWIG_check_num_args("Mezzanine::XML::Node::SetValue",2,2)
19312  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::SetValue",1,"Mezzanine::XML::NamedNodeIterator *");
19313  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::SetValue",2,"Mezzanine::Char8 const *");
19314 
19315  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
19316  SWIG_fail_ptr("NamedNodeIterator_SetValue",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
19317  }
19318 
19319  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
19320  result = (bool)(*arg1)->SetValue((Mezzanine::Char8 const *)arg2);
19321  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
19322  return SWIG_arg;
19323 
19324  if(0) SWIG_fail;
19325 
19326 fail:
19327  lua_error(L);
19328  return SWIG_arg;
19329 }
19330 
19331 
19332 static int _wrap_NamedNodeIterator_AppendAttribute(lua_State* L) {
19333  int SWIG_arg = 0;
19335  Mezzanine::String *arg2 = 0 ;
19336  Mezzanine::String temp2 ;
19338 
19339  SWIG_check_num_args("Mezzanine::XML::Node::AppendAttribute",2,2)
19340  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::AppendAttribute",1,"Mezzanine::XML::NamedNodeIterator *");
19341  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::AppendAttribute",2,"Mezzanine::String const &");
19342 
19343  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
19344  SWIG_fail_ptr("NamedNodeIterator_AppendAttribute",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
19345  }
19346 
19347  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
19348  result = (*arg1)->AppendAttribute((Mezzanine::String const &)*arg2);
19349  {
19351  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Attribute,1); SWIG_arg++;
19352  }
19353  return SWIG_arg;
19354 
19355  if(0) SWIG_fail;
19356 
19357 fail:
19358  lua_error(L);
19359  return SWIG_arg;
19360 }
19361 
19362 
19363 static int _wrap_NamedNodeIterator_PrependAttribute(lua_State* L) {
19364  int SWIG_arg = 0;
19366  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
19368 
19369  SWIG_check_num_args("Mezzanine::XML::Node::PrependAttribute",2,2)
19370  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::PrependAttribute",1,"Mezzanine::XML::NamedNodeIterator *");
19371  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::PrependAttribute",2,"Mezzanine::Char8 const *");
19372 
19373  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
19374  SWIG_fail_ptr("NamedNodeIterator_PrependAttribute",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
19375  }
19376 
19377  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
19378  result = (*arg1)->PrependAttribute((Mezzanine::Char8 const *)arg2);
19379  {
19381  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Attribute,1); SWIG_arg++;
19382  }
19383  return SWIG_arg;
19384 
19385  if(0) SWIG_fail;
19386 
19387 fail:
19388  lua_error(L);
19389  return SWIG_arg;
19390 }
19391 
19392 
19393 static int _wrap_NamedNodeIterator_InsertAttributeAfter(lua_State* L) {
19394  int SWIG_arg = 0;
19396  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
19397  Mezzanine::XML::Attribute *arg3 = 0 ;
19399 
19400  SWIG_check_num_args("Mezzanine::XML::Node::InsertAttributeAfter",3,3)
19401  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::InsertAttributeAfter",1,"Mezzanine::XML::NamedNodeIterator *");
19402  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::InsertAttributeAfter",2,"Mezzanine::Char8 const *");
19403  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::InsertAttributeAfter",3,"Mezzanine::XML::Attribute const &");
19404 
19405  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
19406  SWIG_fail_ptr("NamedNodeIterator_InsertAttributeAfter",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
19407  }
19408 
19409  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
19410 
19411  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
19412  SWIG_fail_ptr("NamedNodeIterator_InsertAttributeAfter",3,SWIGTYPE_p_Mezzanine__XML__Attribute);
19413  }
19414 
19415  result = (*arg1)->InsertAttributeAfter((Mezzanine::Char8 const *)arg2,(Mezzanine::XML::Attribute const &)*arg3);
19416  {
19418  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Attribute,1); SWIG_arg++;
19419  }
19420  return SWIG_arg;
19421 
19422  if(0) SWIG_fail;
19423 
19424 fail:
19425  lua_error(L);
19426  return SWIG_arg;
19427 }
19428 
19429 
19430 static int _wrap_NamedNodeIterator_InsertAttributeBefore(lua_State* L) {
19431  int SWIG_arg = 0;
19433  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
19434  Mezzanine::XML::Attribute *arg3 = 0 ;
19436 
19437  SWIG_check_num_args("Mezzanine::XML::Node::InsertAttributeBefore",3,3)
19438  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::InsertAttributeBefore",1,"Mezzanine::XML::NamedNodeIterator *");
19439  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::InsertAttributeBefore",2,"Mezzanine::Char8 const *");
19440  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::InsertAttributeBefore",3,"Mezzanine::XML::Attribute const &");
19441 
19442  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
19443  SWIG_fail_ptr("NamedNodeIterator_InsertAttributeBefore",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
19444  }
19445 
19446  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
19447 
19448  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
19449  SWIG_fail_ptr("NamedNodeIterator_InsertAttributeBefore",3,SWIGTYPE_p_Mezzanine__XML__Attribute);
19450  }
19451 
19452  result = (*arg1)->InsertAttributeBefore((Mezzanine::Char8 const *)arg2,(Mezzanine::XML::Attribute const &)*arg3);
19453  {
19455  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Attribute,1); SWIG_arg++;
19456  }
19457  return SWIG_arg;
19458 
19459  if(0) SWIG_fail;
19460 
19461 fail:
19462  lua_error(L);
19463  return SWIG_arg;
19464 }
19465 
19466 
19467 static int _wrap_NamedNodeIterator_AppendCopy__SWIG_0(lua_State* L) {
19468  int SWIG_arg = 0;
19470  Mezzanine::XML::Attribute *arg2 = 0 ;
19472 
19473  SWIG_check_num_args("Mezzanine::XML::Node::AppendCopy",2,2)
19474  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::AppendCopy",1,"Mezzanine::XML::NamedNodeIterator *");
19475  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::AppendCopy",2,"Mezzanine::XML::Attribute const &");
19476 
19477  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
19478  SWIG_fail_ptr("NamedNodeIterator_AppendCopy",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
19479  }
19480 
19481 
19482  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
19483  SWIG_fail_ptr("NamedNodeIterator_AppendCopy",2,SWIGTYPE_p_Mezzanine__XML__Attribute);
19484  }
19485 
19486  result = (*arg1)->AppendCopy((Mezzanine::XML::Attribute const &)*arg2);
19487  {
19489  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Attribute,1); SWIG_arg++;
19490  }
19491  return SWIG_arg;
19492 
19493  if(0) SWIG_fail;
19494 
19495 fail:
19496  lua_error(L);
19497  return SWIG_arg;
19498 }
19499 
19500 
19501 static int _wrap_NamedNodeIterator_AppendCopy__SWIG_1(lua_State* L) {
19502  int SWIG_arg = 0;
19504  Mezzanine::XML::Node *arg2 = 0 ;
19505  Mezzanine::XML::Node result;
19506 
19507  SWIG_check_num_args("Mezzanine::XML::Node::AppendCopy",2,2)
19508  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::AppendCopy",1,"Mezzanine::XML::NamedNodeIterator *");
19509  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::AppendCopy",2,"Mezzanine::XML::Node const &");
19510 
19511  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
19512  SWIG_fail_ptr("NamedNodeIterator_AppendCopy",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
19513  }
19514 
19515 
19516  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Node,0))){
19517  SWIG_fail_ptr("NamedNodeIterator_AppendCopy",2,SWIGTYPE_p_Mezzanine__XML__Node);
19518  }
19519 
19520  result = (*arg1)->AppendCopy((Mezzanine::XML::Node const &)*arg2);
19521  {
19522  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
19523  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
19524  }
19525  return SWIG_arg;
19526 
19527  if(0) SWIG_fail;
19528 
19529 fail:
19530  lua_error(L);
19531  return SWIG_arg;
19532 }
19533 
19534 
19535 static int _wrap_NamedNodeIterator_AppendCopy(lua_State* L) {
19536  int argc;
19537  int argv[3]={
19538  1,2,3
19539  };
19540 
19541  argc = lua_gettop(L);
19542  if (argc == 2) {
19543  int _v;
19544  {
19545  void *ptr;
19546  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator, 0)) {
19547  _v = 0;
19548  } else {
19549  _v = 1;
19550  }
19551  }
19552  if (_v) {
19553  {
19554  void *ptr;
19555  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Attribute, 0)) {
19556  _v = 0;
19557  } else {
19558  _v = 1;
19559  }
19560  }
19561  if (_v) {
19562  return _wrap_NamedNodeIterator_AppendCopy__SWIG_0(L);
19563  }
19564  }
19565  }
19566  if (argc == 2) {
19567  int _v;
19568  {
19569  void *ptr;
19570  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator, 0)) {
19571  _v = 0;
19572  } else {
19573  _v = 1;
19574  }
19575  }
19576  if (_v) {
19577  {
19578  void *ptr;
19579  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
19580  _v = 0;
19581  } else {
19582  _v = 1;
19583  }
19584  }
19585  if (_v) {
19586  return _wrap_NamedNodeIterator_AppendCopy__SWIG_1(L);
19587  }
19588  }
19589  }
19590 
19591  lua_pushstring(L,"Wrong arguments for overloaded function 'NamedNodeIterator_AppendCopy'\n"
19592  " Possible C/C++ prototypes are:\n"
19593  " Mezzanine::XML::Node::AppendCopy(Mezzanine::XML::Attribute const &)\n"
19594  " Mezzanine::XML::Node::AppendCopy(Mezzanine::XML::Node const &)\n");
19595  lua_error(L);return 0;
19596 }
19597 
19598 
19599 static int _wrap_NamedNodeIterator_PrependCopy__SWIG_0(lua_State* L) {
19600  int SWIG_arg = 0;
19602  Mezzanine::XML::Attribute *arg2 = 0 ;
19604 
19605  SWIG_check_num_args("Mezzanine::XML::Node::PrependCopy",2,2)
19606  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::PrependCopy",1,"Mezzanine::XML::NamedNodeIterator *");
19607  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::PrependCopy",2,"Mezzanine::XML::Attribute const &");
19608 
19609  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
19610  SWIG_fail_ptr("NamedNodeIterator_PrependCopy",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
19611  }
19612 
19613 
19614  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
19615  SWIG_fail_ptr("NamedNodeIterator_PrependCopy",2,SWIGTYPE_p_Mezzanine__XML__Attribute);
19616  }
19617 
19618  result = (*arg1)->PrependCopy((Mezzanine::XML::Attribute const &)*arg2);
19619  {
19621  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Attribute,1); SWIG_arg++;
19622  }
19623  return SWIG_arg;
19624 
19625  if(0) SWIG_fail;
19626 
19627 fail:
19628  lua_error(L);
19629  return SWIG_arg;
19630 }
19631 
19632 
19633 static int _wrap_NamedNodeIterator_PrependCopy__SWIG_1(lua_State* L) {
19634  int SWIG_arg = 0;
19636  Mezzanine::XML::Node *arg2 = 0 ;
19637  Mezzanine::XML::Node result;
19638 
19639  SWIG_check_num_args("Mezzanine::XML::Node::PrependCopy",2,2)
19640  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::PrependCopy",1,"Mezzanine::XML::NamedNodeIterator *");
19641  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::PrependCopy",2,"Mezzanine::XML::Node const &");
19642 
19643  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
19644  SWIG_fail_ptr("NamedNodeIterator_PrependCopy",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
19645  }
19646 
19647 
19648  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Node,0))){
19649  SWIG_fail_ptr("NamedNodeIterator_PrependCopy",2,SWIGTYPE_p_Mezzanine__XML__Node);
19650  }
19651 
19652  result = (*arg1)->PrependCopy((Mezzanine::XML::Node const &)*arg2);
19653  {
19654  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
19655  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
19656  }
19657  return SWIG_arg;
19658 
19659  if(0) SWIG_fail;
19660 
19661 fail:
19662  lua_error(L);
19663  return SWIG_arg;
19664 }
19665 
19666 
19667 static int _wrap_NamedNodeIterator_PrependCopy(lua_State* L) {
19668  int argc;
19669  int argv[3]={
19670  1,2,3
19671  };
19672 
19673  argc = lua_gettop(L);
19674  if (argc == 2) {
19675  int _v;
19676  {
19677  void *ptr;
19678  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator, 0)) {
19679  _v = 0;
19680  } else {
19681  _v = 1;
19682  }
19683  }
19684  if (_v) {
19685  {
19686  void *ptr;
19687  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Attribute, 0)) {
19688  _v = 0;
19689  } else {
19690  _v = 1;
19691  }
19692  }
19693  if (_v) {
19694  return _wrap_NamedNodeIterator_PrependCopy__SWIG_0(L);
19695  }
19696  }
19697  }
19698  if (argc == 2) {
19699  int _v;
19700  {
19701  void *ptr;
19702  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator, 0)) {
19703  _v = 0;
19704  } else {
19705  _v = 1;
19706  }
19707  }
19708  if (_v) {
19709  {
19710  void *ptr;
19711  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
19712  _v = 0;
19713  } else {
19714  _v = 1;
19715  }
19716  }
19717  if (_v) {
19718  return _wrap_NamedNodeIterator_PrependCopy__SWIG_1(L);
19719  }
19720  }
19721  }
19722 
19723  lua_pushstring(L,"Wrong arguments for overloaded function 'NamedNodeIterator_PrependCopy'\n"
19724  " Possible C/C++ prototypes are:\n"
19725  " Mezzanine::XML::Node::PrependCopy(Mezzanine::XML::Attribute const &)\n"
19726  " Mezzanine::XML::Node::PrependCopy(Mezzanine::XML::Node const &)\n");
19727  lua_error(L);return 0;
19728 }
19729 
19730 
19731 static int _wrap_NamedNodeIterator_InsertCopyAfter__SWIG_0(lua_State* L) {
19732  int SWIG_arg = 0;
19734  Mezzanine::XML::Attribute *arg2 = 0 ;
19735  Mezzanine::XML::Attribute *arg3 = 0 ;
19737 
19738  SWIG_check_num_args("Mezzanine::XML::Node::InsertCopyAfter",3,3)
19739  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::InsertCopyAfter",1,"Mezzanine::XML::NamedNodeIterator *");
19740  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::InsertCopyAfter",2,"Mezzanine::XML::Attribute const &");
19741  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::InsertCopyAfter",3,"Mezzanine::XML::Attribute const &");
19742 
19743  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
19744  SWIG_fail_ptr("NamedNodeIterator_InsertCopyAfter",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
19745  }
19746 
19747 
19748  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
19749  SWIG_fail_ptr("NamedNodeIterator_InsertCopyAfter",2,SWIGTYPE_p_Mezzanine__XML__Attribute);
19750  }
19751 
19752 
19753  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
19754  SWIG_fail_ptr("NamedNodeIterator_InsertCopyAfter",3,SWIGTYPE_p_Mezzanine__XML__Attribute);
19755  }
19756 
19757  result = (*arg1)->InsertCopyAfter((Mezzanine::XML::Attribute const &)*arg2,(Mezzanine::XML::Attribute const &)*arg3);
19758  {
19760  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Attribute,1); SWIG_arg++;
19761  }
19762  return SWIG_arg;
19763 
19764  if(0) SWIG_fail;
19765 
19766 fail:
19767  lua_error(L);
19768  return SWIG_arg;
19769 }
19770 
19771 
19772 static int _wrap_NamedNodeIterator_InsertCopyAfter__SWIG_1(lua_State* L) {
19773  int SWIG_arg = 0;
19775  Mezzanine::XML::Node *arg2 = 0 ;
19776  Mezzanine::XML::Node *arg3 = 0 ;
19777  Mezzanine::XML::Node result;
19778 
19779  SWIG_check_num_args("Mezzanine::XML::Node::InsertCopyAfter",3,3)
19780  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::InsertCopyAfter",1,"Mezzanine::XML::NamedNodeIterator *");
19781  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::InsertCopyAfter",2,"Mezzanine::XML::Node const &");
19782  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::InsertCopyAfter",3,"Mezzanine::XML::Node const &");
19783 
19784  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
19785  SWIG_fail_ptr("NamedNodeIterator_InsertCopyAfter",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
19786  }
19787 
19788 
19789  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Node,0))){
19790  SWIG_fail_ptr("NamedNodeIterator_InsertCopyAfter",2,SWIGTYPE_p_Mezzanine__XML__Node);
19791  }
19792 
19793 
19794  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__XML__Node,0))){
19795  SWIG_fail_ptr("NamedNodeIterator_InsertCopyAfter",3,SWIGTYPE_p_Mezzanine__XML__Node);
19796  }
19797 
19798  result = (*arg1)->InsertCopyAfter((Mezzanine::XML::Node const &)*arg2,(Mezzanine::XML::Node const &)*arg3);
19799  {
19800  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
19801  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
19802  }
19803  return SWIG_arg;
19804 
19805  if(0) SWIG_fail;
19806 
19807 fail:
19808  lua_error(L);
19809  return SWIG_arg;
19810 }
19811 
19812 
19813 static int _wrap_NamedNodeIterator_InsertCopyAfter(lua_State* L) {
19814  int argc;
19815  int argv[4]={
19816  1,2,3,4
19817  };
19818 
19819  argc = lua_gettop(L);
19820  if (argc == 3) {
19821  int _v;
19822  {
19823  void *ptr;
19824  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator, 0)) {
19825  _v = 0;
19826  } else {
19827  _v = 1;
19828  }
19829  }
19830  if (_v) {
19831  {
19832  void *ptr;
19833  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Attribute, 0)) {
19834  _v = 0;
19835  } else {
19836  _v = 1;
19837  }
19838  }
19839  if (_v) {
19840  {
19841  void *ptr;
19842  if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Attribute, 0)) {
19843  _v = 0;
19844  } else {
19845  _v = 1;
19846  }
19847  }
19848  if (_v) {
19849  return _wrap_NamedNodeIterator_InsertCopyAfter__SWIG_0(L);
19850  }
19851  }
19852  }
19853  }
19854  if (argc == 3) {
19855  int _v;
19856  {
19857  void *ptr;
19858  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator, 0)) {
19859  _v = 0;
19860  } else {
19861  _v = 1;
19862  }
19863  }
19864  if (_v) {
19865  {
19866  void *ptr;
19867  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
19868  _v = 0;
19869  } else {
19870  _v = 1;
19871  }
19872  }
19873  if (_v) {
19874  {
19875  void *ptr;
19876  if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
19877  _v = 0;
19878  } else {
19879  _v = 1;
19880  }
19881  }
19882  if (_v) {
19883  return _wrap_NamedNodeIterator_InsertCopyAfter__SWIG_1(L);
19884  }
19885  }
19886  }
19887  }
19888 
19889  lua_pushstring(L,"Wrong arguments for overloaded function 'NamedNodeIterator_InsertCopyAfter'\n"
19890  " Possible C/C++ prototypes are:\n"
19891  " Mezzanine::XML::Node::InsertCopyAfter(Mezzanine::XML::Attribute const &,Mezzanine::XML::Attribute const &)\n"
19892  " Mezzanine::XML::Node::InsertCopyAfter(Mezzanine::XML::Node const &,Mezzanine::XML::Node const &)\n");
19893  lua_error(L);return 0;
19894 }
19895 
19896 
19897 static int _wrap_NamedNodeIterator_InsertCopyBefore__SWIG_0(lua_State* L) {
19898  int SWIG_arg = 0;
19900  Mezzanine::XML::Attribute *arg2 = 0 ;
19901  Mezzanine::XML::Attribute *arg3 = 0 ;
19903 
19904  SWIG_check_num_args("Mezzanine::XML::Node::InsertCopyBefore",3,3)
19905  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::InsertCopyBefore",1,"Mezzanine::XML::NamedNodeIterator *");
19906  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::InsertCopyBefore",2,"Mezzanine::XML::Attribute const &");
19907  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::InsertCopyBefore",3,"Mezzanine::XML::Attribute const &");
19908 
19909  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
19910  SWIG_fail_ptr("NamedNodeIterator_InsertCopyBefore",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
19911  }
19912 
19913 
19914  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
19915  SWIG_fail_ptr("NamedNodeIterator_InsertCopyBefore",2,SWIGTYPE_p_Mezzanine__XML__Attribute);
19916  }
19917 
19918 
19919  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
19920  SWIG_fail_ptr("NamedNodeIterator_InsertCopyBefore",3,SWIGTYPE_p_Mezzanine__XML__Attribute);
19921  }
19922 
19923  result = (*arg1)->InsertCopyBefore((Mezzanine::XML::Attribute const &)*arg2,(Mezzanine::XML::Attribute const &)*arg3);
19924  {
19926  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Attribute,1); SWIG_arg++;
19927  }
19928  return SWIG_arg;
19929 
19930  if(0) SWIG_fail;
19931 
19932 fail:
19933  lua_error(L);
19934  return SWIG_arg;
19935 }
19936 
19937 
19938 static int _wrap_NamedNodeIterator_InsertCopyBefore__SWIG_1(lua_State* L) {
19939  int SWIG_arg = 0;
19941  Mezzanine::XML::Node *arg2 = 0 ;
19942  Mezzanine::XML::Node *arg3 = 0 ;
19943  Mezzanine::XML::Node result;
19944 
19945  SWIG_check_num_args("Mezzanine::XML::Node::InsertCopyBefore",3,3)
19946  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::InsertCopyBefore",1,"Mezzanine::XML::NamedNodeIterator *");
19947  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::InsertCopyBefore",2,"Mezzanine::XML::Node const &");
19948  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::InsertCopyBefore",3,"Mezzanine::XML::Node const &");
19949 
19950  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
19951  SWIG_fail_ptr("NamedNodeIterator_InsertCopyBefore",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
19952  }
19953 
19954 
19955  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Node,0))){
19956  SWIG_fail_ptr("NamedNodeIterator_InsertCopyBefore",2,SWIGTYPE_p_Mezzanine__XML__Node);
19957  }
19958 
19959 
19960  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__XML__Node,0))){
19961  SWIG_fail_ptr("NamedNodeIterator_InsertCopyBefore",3,SWIGTYPE_p_Mezzanine__XML__Node);
19962  }
19963 
19964  result = (*arg1)->InsertCopyBefore((Mezzanine::XML::Node const &)*arg2,(Mezzanine::XML::Node const &)*arg3);
19965  {
19966  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
19967  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
19968  }
19969  return SWIG_arg;
19970 
19971  if(0) SWIG_fail;
19972 
19973 fail:
19974  lua_error(L);
19975  return SWIG_arg;
19976 }
19977 
19978 
19979 static int _wrap_NamedNodeIterator_InsertCopyBefore(lua_State* L) {
19980  int argc;
19981  int argv[4]={
19982  1,2,3,4
19983  };
19984 
19985  argc = lua_gettop(L);
19986  if (argc == 3) {
19987  int _v;
19988  {
19989  void *ptr;
19990  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator, 0)) {
19991  _v = 0;
19992  } else {
19993  _v = 1;
19994  }
19995  }
19996  if (_v) {
19997  {
19998  void *ptr;
19999  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Attribute, 0)) {
20000  _v = 0;
20001  } else {
20002  _v = 1;
20003  }
20004  }
20005  if (_v) {
20006  {
20007  void *ptr;
20008  if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Attribute, 0)) {
20009  _v = 0;
20010  } else {
20011  _v = 1;
20012  }
20013  }
20014  if (_v) {
20015  return _wrap_NamedNodeIterator_InsertCopyBefore__SWIG_0(L);
20016  }
20017  }
20018  }
20019  }
20020  if (argc == 3) {
20021  int _v;
20022  {
20023  void *ptr;
20024  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator, 0)) {
20025  _v = 0;
20026  } else {
20027  _v = 1;
20028  }
20029  }
20030  if (_v) {
20031  {
20032  void *ptr;
20033  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
20034  _v = 0;
20035  } else {
20036  _v = 1;
20037  }
20038  }
20039  if (_v) {
20040  {
20041  void *ptr;
20042  if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
20043  _v = 0;
20044  } else {
20045  _v = 1;
20046  }
20047  }
20048  if (_v) {
20049  return _wrap_NamedNodeIterator_InsertCopyBefore__SWIG_1(L);
20050  }
20051  }
20052  }
20053  }
20054 
20055  lua_pushstring(L,"Wrong arguments for overloaded function 'NamedNodeIterator_InsertCopyBefore'\n"
20056  " Possible C/C++ prototypes are:\n"
20057  " Mezzanine::XML::Node::InsertCopyBefore(Mezzanine::XML::Attribute const &,Mezzanine::XML::Attribute const &)\n"
20058  " Mezzanine::XML::Node::InsertCopyBefore(Mezzanine::XML::Node const &,Mezzanine::XML::Node const &)\n");
20059  lua_error(L);return 0;
20060 }
20061 
20062 
20063 static int _wrap_NamedNodeIterator_AppendChild__SWIG_0(lua_State* L) {
20064  int SWIG_arg = 0;
20067  Mezzanine::XML::Node result;
20068 
20069  SWIG_check_num_args("Mezzanine::XML::Node::AppendChild",2,2)
20070  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::AppendChild",1,"Mezzanine::XML::NamedNodeIterator *");
20071  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::AppendChild",2,"Mezzanine::XML::NodeType");
20072 
20073  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
20074  SWIG_fail_ptr("NamedNodeIterator_AppendChild",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
20075  }
20076 
20077  arg2 = (Mezzanine::XML::NodeType)(int)lua_tonumber(L, 2);
20078  result = (*arg1)->AppendChild(arg2);
20079  {
20080  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
20081  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
20082  }
20083  return SWIG_arg;
20084 
20085  if(0) SWIG_fail;
20086 
20087 fail:
20088  lua_error(L);
20089  return SWIG_arg;
20090 }
20091 
20092 
20093 static int _wrap_NamedNodeIterator_AppendChild__SWIG_1(lua_State* L) {
20094  int SWIG_arg = 0;
20096  Mezzanine::XML::Node result;
20097 
20098  SWIG_check_num_args("Mezzanine::XML::Node::AppendChild",1,1)
20099  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::AppendChild",1,"Mezzanine::XML::NamedNodeIterator *");
20100 
20101  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
20102  SWIG_fail_ptr("NamedNodeIterator_AppendChild",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
20103  }
20104 
20105  result = (*arg1)->AppendChild();
20106  {
20107  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
20108  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
20109  }
20110  return SWIG_arg;
20111 
20112  if(0) SWIG_fail;
20113 
20114 fail:
20115  lua_error(L);
20116  return SWIG_arg;
20117 }
20118 
20119 
20120 static int _wrap_NamedNodeIterator_AppendChild__SWIG_2(lua_State* L) {
20121  int SWIG_arg = 0;
20123  Mezzanine::String *arg2 = 0 ;
20124  Mezzanine::String temp2 ;
20125  Mezzanine::XML::Node result;
20126 
20127  SWIG_check_num_args("Mezzanine::XML::Node::AppendChild",2,2)
20128  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::AppendChild",1,"Mezzanine::XML::NamedNodeIterator *");
20129  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::AppendChild",2,"Mezzanine::String const &");
20130 
20131  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
20132  SWIG_fail_ptr("NamedNodeIterator_AppendChild",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
20133  }
20134 
20135  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
20136  result = (*arg1)->AppendChild((Mezzanine::String const &)*arg2);
20137  {
20138  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
20139  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
20140  }
20141  return SWIG_arg;
20142 
20143  if(0) SWIG_fail;
20144 
20145 fail:
20146  lua_error(L);
20147  return SWIG_arg;
20148 }
20149 
20150 
20151 static int _wrap_NamedNodeIterator_AppendChild(lua_State* L) {
20152  int argc;
20153  int argv[3]={
20154  1,2,3
20155  };
20156 
20157  argc = lua_gettop(L);
20158  if (argc == 1) {
20159  int _v;
20160  {
20161  void *ptr;
20162  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator, 0)) {
20163  _v = 0;
20164  } else {
20165  _v = 1;
20166  }
20167  }
20168  if (_v) {
20169  return _wrap_NamedNodeIterator_AppendChild__SWIG_1(L);
20170  }
20171  }
20172  if (argc == 2) {
20173  int _v;
20174  {
20175  void *ptr;
20176  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator, 0)) {
20177  _v = 0;
20178  } else {
20179  _v = 1;
20180  }
20181  }
20182  if (_v) {
20183  {
20184  _v = lua_isnumber(L,argv[1]);
20185  }
20186  if (_v) {
20187  return _wrap_NamedNodeIterator_AppendChild__SWIG_0(L);
20188  }
20189  }
20190  }
20191  if (argc == 2) {
20192  int _v;
20193  {
20194  void *ptr;
20195  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator, 0)) {
20196  _v = 0;
20197  } else {
20198  _v = 1;
20199  }
20200  }
20201  if (_v) {
20202  {
20203  _v = lua_isstring(L,argv[1]);
20204  }
20205  if (_v) {
20206  return _wrap_NamedNodeIterator_AppendChild__SWIG_2(L);
20207  }
20208  }
20209  }
20210 
20211  lua_pushstring(L,"Wrong arguments for overloaded function 'NamedNodeIterator_AppendChild'\n"
20212  " Possible C/C++ prototypes are:\n"
20213  " Mezzanine::XML::Node::AppendChild(Mezzanine::XML::NodeType)\n"
20214  " Mezzanine::XML::Node::AppendChild()\n"
20215  " Mezzanine::XML::Node::AppendChild(Mezzanine::String const &)\n");
20216  lua_error(L);return 0;
20217 }
20218 
20219 
20220 static int _wrap_NamedNodeIterator_PrependChild__SWIG_0(lua_State* L) {
20221  int SWIG_arg = 0;
20224  Mezzanine::XML::Node result;
20225 
20226  SWIG_check_num_args("Mezzanine::XML::Node::PrependChild",2,2)
20227  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::PrependChild",1,"Mezzanine::XML::NamedNodeIterator *");
20228  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::PrependChild",2,"Mezzanine::XML::NodeType");
20229 
20230  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
20231  SWIG_fail_ptr("NamedNodeIterator_PrependChild",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
20232  }
20233 
20234  arg2 = (Mezzanine::XML::NodeType)(int)lua_tonumber(L, 2);
20235  result = (*arg1)->PrependChild(arg2);
20236  {
20237  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
20238  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
20239  }
20240  return SWIG_arg;
20241 
20242  if(0) SWIG_fail;
20243 
20244 fail:
20245  lua_error(L);
20246  return SWIG_arg;
20247 }
20248 
20249 
20250 static int _wrap_NamedNodeIterator_PrependChild__SWIG_1(lua_State* L) {
20251  int SWIG_arg = 0;
20253  Mezzanine::XML::Node result;
20254 
20255  SWIG_check_num_args("Mezzanine::XML::Node::PrependChild",1,1)
20256  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::PrependChild",1,"Mezzanine::XML::NamedNodeIterator *");
20257 
20258  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
20259  SWIG_fail_ptr("NamedNodeIterator_PrependChild",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
20260  }
20261 
20262  result = (*arg1)->PrependChild();
20263  {
20264  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
20265  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
20266  }
20267  return SWIG_arg;
20268 
20269  if(0) SWIG_fail;
20270 
20271 fail:
20272  lua_error(L);
20273  return SWIG_arg;
20274 }
20275 
20276 
20277 static int _wrap_NamedNodeIterator_PrependChild__SWIG_2(lua_State* L) {
20278  int SWIG_arg = 0;
20280  Mezzanine::String *arg2 = 0 ;
20281  Mezzanine::String temp2 ;
20282  Mezzanine::XML::Node result;
20283 
20284  SWIG_check_num_args("Mezzanine::XML::Node::PrependChild",2,2)
20285  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::PrependChild",1,"Mezzanine::XML::NamedNodeIterator *");
20286  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::PrependChild",2,"Mezzanine::String const &");
20287 
20288  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
20289  SWIG_fail_ptr("NamedNodeIterator_PrependChild",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
20290  }
20291 
20292  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
20293  result = (*arg1)->PrependChild((Mezzanine::String const &)*arg2);
20294  {
20295  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
20296  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
20297  }
20298  return SWIG_arg;
20299 
20300  if(0) SWIG_fail;
20301 
20302 fail:
20303  lua_error(L);
20304  return SWIG_arg;
20305 }
20306 
20307 
20308 static int _wrap_NamedNodeIterator_PrependChild(lua_State* L) {
20309  int argc;
20310  int argv[3]={
20311  1,2,3
20312  };
20313 
20314  argc = lua_gettop(L);
20315  if (argc == 1) {
20316  int _v;
20317  {
20318  void *ptr;
20319  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator, 0)) {
20320  _v = 0;
20321  } else {
20322  _v = 1;
20323  }
20324  }
20325  if (_v) {
20326  return _wrap_NamedNodeIterator_PrependChild__SWIG_1(L);
20327  }
20328  }
20329  if (argc == 2) {
20330  int _v;
20331  {
20332  void *ptr;
20333  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator, 0)) {
20334  _v = 0;
20335  } else {
20336  _v = 1;
20337  }
20338  }
20339  if (_v) {
20340  {
20341  _v = lua_isnumber(L,argv[1]);
20342  }
20343  if (_v) {
20344  return _wrap_NamedNodeIterator_PrependChild__SWIG_0(L);
20345  }
20346  }
20347  }
20348  if (argc == 2) {
20349  int _v;
20350  {
20351  void *ptr;
20352  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator, 0)) {
20353  _v = 0;
20354  } else {
20355  _v = 1;
20356  }
20357  }
20358  if (_v) {
20359  {
20360  _v = lua_isstring(L,argv[1]);
20361  }
20362  if (_v) {
20363  return _wrap_NamedNodeIterator_PrependChild__SWIG_2(L);
20364  }
20365  }
20366  }
20367 
20368  lua_pushstring(L,"Wrong arguments for overloaded function 'NamedNodeIterator_PrependChild'\n"
20369  " Possible C/C++ prototypes are:\n"
20370  " Mezzanine::XML::Node::PrependChild(Mezzanine::XML::NodeType)\n"
20371  " Mezzanine::XML::Node::PrependChild()\n"
20372  " Mezzanine::XML::Node::PrependChild(Mezzanine::String const &)\n");
20373  lua_error(L);return 0;
20374 }
20375 
20376 
20377 static int _wrap_NamedNodeIterator_InsertChildAfter__SWIG_0(lua_State* L) {
20378  int SWIG_arg = 0;
20381  Mezzanine::XML::Node *arg3 = 0 ;
20382  Mezzanine::XML::Node result;
20383 
20384  SWIG_check_num_args("Mezzanine::XML::Node::InsertChildAfter",3,3)
20385  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::InsertChildAfter",1,"Mezzanine::XML::NamedNodeIterator *");
20386  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::InsertChildAfter",2,"Mezzanine::XML::NodeType");
20387  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::InsertChildAfter",3,"Mezzanine::XML::Node const &");
20388 
20389  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
20390  SWIG_fail_ptr("NamedNodeIterator_InsertChildAfter",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
20391  }
20392 
20393  arg2 = (Mezzanine::XML::NodeType)(int)lua_tonumber(L, 2);
20394 
20395  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__XML__Node,0))){
20396  SWIG_fail_ptr("NamedNodeIterator_InsertChildAfter",3,SWIGTYPE_p_Mezzanine__XML__Node);
20397  }
20398 
20399  result = (*arg1)->InsertChildAfter(arg2,(Mezzanine::XML::Node const &)*arg3);
20400  {
20401  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
20402  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
20403  }
20404  return SWIG_arg;
20405 
20406  if(0) SWIG_fail;
20407 
20408 fail:
20409  lua_error(L);
20410  return SWIG_arg;
20411 }
20412 
20413 
20414 static int _wrap_NamedNodeIterator_InsertChildAfter__SWIG_1(lua_State* L) {
20415  int SWIG_arg = 0;
20417  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
20418  Mezzanine::XML::Node *arg3 = 0 ;
20419  Mezzanine::XML::Node result;
20420 
20421  SWIG_check_num_args("Mezzanine::XML::Node::InsertChildAfter",3,3)
20422  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::InsertChildAfter",1,"Mezzanine::XML::NamedNodeIterator *");
20423  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::InsertChildAfter",2,"Mezzanine::Char8 const *");
20424  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::InsertChildAfter",3,"Mezzanine::XML::Node const &");
20425 
20426  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
20427  SWIG_fail_ptr("NamedNodeIterator_InsertChildAfter",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
20428  }
20429 
20430  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
20431 
20432  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__XML__Node,0))){
20433  SWIG_fail_ptr("NamedNodeIterator_InsertChildAfter",3,SWIGTYPE_p_Mezzanine__XML__Node);
20434  }
20435 
20436  result = (*arg1)->InsertChildAfter((Mezzanine::Char8 const *)arg2,(Mezzanine::XML::Node const &)*arg3);
20437  {
20438  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
20439  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
20440  }
20441  return SWIG_arg;
20442 
20443  if(0) SWIG_fail;
20444 
20445 fail:
20446  lua_error(L);
20447  return SWIG_arg;
20448 }
20449 
20450 
20451 static int _wrap_NamedNodeIterator_InsertChildAfter(lua_State* L) {
20452  int argc;
20453  int argv[4]={
20454  1,2,3,4
20455  };
20456 
20457  argc = lua_gettop(L);
20458  if (argc == 3) {
20459  int _v;
20460  {
20461  void *ptr;
20462  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator, 0)) {
20463  _v = 0;
20464  } else {
20465  _v = 1;
20466  }
20467  }
20468  if (_v) {
20469  {
20470  _v = lua_isnumber(L,argv[1]);
20471  }
20472  if (_v) {
20473  {
20474  void *ptr;
20475  if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
20476  _v = 0;
20477  } else {
20478  _v = 1;
20479  }
20480  }
20481  if (_v) {
20482  return _wrap_NamedNodeIterator_InsertChildAfter__SWIG_0(L);
20483  }
20484  }
20485  }
20486  }
20487  if (argc == 3) {
20488  int _v;
20489  {
20490  void *ptr;
20491  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator, 0)) {
20492  _v = 0;
20493  } else {
20494  _v = 1;
20495  }
20496  }
20497  if (_v) {
20498  {
20499  _v = SWIG_lua_isnilstring(L,argv[1]);
20500  }
20501  if (_v) {
20502  {
20503  void *ptr;
20504  if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
20505  _v = 0;
20506  } else {
20507  _v = 1;
20508  }
20509  }
20510  if (_v) {
20511  return _wrap_NamedNodeIterator_InsertChildAfter__SWIG_1(L);
20512  }
20513  }
20514  }
20515  }
20516 
20517  lua_pushstring(L,"Wrong arguments for overloaded function 'NamedNodeIterator_InsertChildAfter'\n"
20518  " Possible C/C++ prototypes are:\n"
20519  " Mezzanine::XML::Node::InsertChildAfter(Mezzanine::XML::NodeType,Mezzanine::XML::Node const &)\n"
20520  " Mezzanine::XML::Node::InsertChildAfter(Mezzanine::Char8 const *,Mezzanine::XML::Node const &)\n");
20521  lua_error(L);return 0;
20522 }
20523 
20524 
20525 static int _wrap_NamedNodeIterator_InsertChildBefore__SWIG_0(lua_State* L) {
20526  int SWIG_arg = 0;
20529  Mezzanine::XML::Node *arg3 = 0 ;
20530  Mezzanine::XML::Node result;
20531 
20532  SWIG_check_num_args("Mezzanine::XML::Node::InsertChildBefore",3,3)
20533  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::InsertChildBefore",1,"Mezzanine::XML::NamedNodeIterator *");
20534  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::InsertChildBefore",2,"Mezzanine::XML::NodeType");
20535  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::InsertChildBefore",3,"Mezzanine::XML::Node const &");
20536 
20537  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
20538  SWIG_fail_ptr("NamedNodeIterator_InsertChildBefore",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
20539  }
20540 
20541  arg2 = (Mezzanine::XML::NodeType)(int)lua_tonumber(L, 2);
20542 
20543  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__XML__Node,0))){
20544  SWIG_fail_ptr("NamedNodeIterator_InsertChildBefore",3,SWIGTYPE_p_Mezzanine__XML__Node);
20545  }
20546 
20547  result = (*arg1)->InsertChildBefore(arg2,(Mezzanine::XML::Node const &)*arg3);
20548  {
20549  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
20550  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
20551  }
20552  return SWIG_arg;
20553 
20554  if(0) SWIG_fail;
20555 
20556 fail:
20557  lua_error(L);
20558  return SWIG_arg;
20559 }
20560 
20561 
20562 static int _wrap_NamedNodeIterator_InsertChildBefore__SWIG_1(lua_State* L) {
20563  int SWIG_arg = 0;
20565  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
20566  Mezzanine::XML::Node *arg3 = 0 ;
20567  Mezzanine::XML::Node result;
20568 
20569  SWIG_check_num_args("Mezzanine::XML::Node::InsertChildBefore",3,3)
20570  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::InsertChildBefore",1,"Mezzanine::XML::NamedNodeIterator *");
20571  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::InsertChildBefore",2,"Mezzanine::Char8 const *");
20572  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::InsertChildBefore",3,"Mezzanine::XML::Node const &");
20573 
20574  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
20575  SWIG_fail_ptr("NamedNodeIterator_InsertChildBefore",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
20576  }
20577 
20578  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
20579 
20580  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__XML__Node,0))){
20581  SWIG_fail_ptr("NamedNodeIterator_InsertChildBefore",3,SWIGTYPE_p_Mezzanine__XML__Node);
20582  }
20583 
20584  result = (*arg1)->InsertChildBefore((Mezzanine::Char8 const *)arg2,(Mezzanine::XML::Node const &)*arg3);
20585  {
20586  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
20587  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
20588  }
20589  return SWIG_arg;
20590 
20591  if(0) SWIG_fail;
20592 
20593 fail:
20594  lua_error(L);
20595  return SWIG_arg;
20596 }
20597 
20598 
20599 static int _wrap_NamedNodeIterator_InsertChildBefore(lua_State* L) {
20600  int argc;
20601  int argv[4]={
20602  1,2,3,4
20603  };
20604 
20605  argc = lua_gettop(L);
20606  if (argc == 3) {
20607  int _v;
20608  {
20609  void *ptr;
20610  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator, 0)) {
20611  _v = 0;
20612  } else {
20613  _v = 1;
20614  }
20615  }
20616  if (_v) {
20617  {
20618  _v = lua_isnumber(L,argv[1]);
20619  }
20620  if (_v) {
20621  {
20622  void *ptr;
20623  if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
20624  _v = 0;
20625  } else {
20626  _v = 1;
20627  }
20628  }
20629  if (_v) {
20630  return _wrap_NamedNodeIterator_InsertChildBefore__SWIG_0(L);
20631  }
20632  }
20633  }
20634  }
20635  if (argc == 3) {
20636  int _v;
20637  {
20638  void *ptr;
20639  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator, 0)) {
20640  _v = 0;
20641  } else {
20642  _v = 1;
20643  }
20644  }
20645  if (_v) {
20646  {
20647  _v = SWIG_lua_isnilstring(L,argv[1]);
20648  }
20649  if (_v) {
20650  {
20651  void *ptr;
20652  if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
20653  _v = 0;
20654  } else {
20655  _v = 1;
20656  }
20657  }
20658  if (_v) {
20659  return _wrap_NamedNodeIterator_InsertChildBefore__SWIG_1(L);
20660  }
20661  }
20662  }
20663  }
20664 
20665  lua_pushstring(L,"Wrong arguments for overloaded function 'NamedNodeIterator_InsertChildBefore'\n"
20666  " Possible C/C++ prototypes are:\n"
20667  " Mezzanine::XML::Node::InsertChildBefore(Mezzanine::XML::NodeType,Mezzanine::XML::Node const &)\n"
20668  " Mezzanine::XML::Node::InsertChildBefore(Mezzanine::Char8 const *,Mezzanine::XML::Node const &)\n");
20669  lua_error(L);return 0;
20670 }
20671 
20672 
20673 static int _wrap_NamedNodeIterator_RemoveAttribute__SWIG_0(lua_State* L) {
20674  int SWIG_arg = 0;
20676  Mezzanine::XML::Attribute *arg2 = 0 ;
20677  bool result;
20678 
20679  SWIG_check_num_args("Mezzanine::XML::Node::RemoveAttribute",2,2)
20680  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::RemoveAttribute",1,"Mezzanine::XML::NamedNodeIterator *");
20681  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::RemoveAttribute",2,"Mezzanine::XML::Attribute const &");
20682 
20683  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
20684  SWIG_fail_ptr("NamedNodeIterator_RemoveAttribute",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
20685  }
20686 
20687 
20688  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
20689  SWIG_fail_ptr("NamedNodeIterator_RemoveAttribute",2,SWIGTYPE_p_Mezzanine__XML__Attribute);
20690  }
20691 
20692  result = (bool)(*arg1)->RemoveAttribute((Mezzanine::XML::Attribute const &)*arg2);
20693  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
20694  return SWIG_arg;
20695 
20696  if(0) SWIG_fail;
20697 
20698 fail:
20699  lua_error(L);
20700  return SWIG_arg;
20701 }
20702 
20703 
20704 static int _wrap_NamedNodeIterator_RemoveAttribute__SWIG_1(lua_State* L) {
20705  int SWIG_arg = 0;
20707  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
20708  bool result;
20709 
20710  SWIG_check_num_args("Mezzanine::XML::Node::RemoveAttribute",2,2)
20711  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::RemoveAttribute",1,"Mezzanine::XML::NamedNodeIterator *");
20712  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::RemoveAttribute",2,"Mezzanine::Char8 const *");
20713 
20714  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
20715  SWIG_fail_ptr("NamedNodeIterator_RemoveAttribute",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
20716  }
20717 
20718  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
20719  result = (bool)(*arg1)->RemoveAttribute((Mezzanine::Char8 const *)arg2);
20720  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
20721  return SWIG_arg;
20722 
20723  if(0) SWIG_fail;
20724 
20725 fail:
20726  lua_error(L);
20727  return SWIG_arg;
20728 }
20729 
20730 
20731 static int _wrap_NamedNodeIterator_RemoveAttribute(lua_State* L) {
20732  int argc;
20733  int argv[3]={
20734  1,2,3
20735  };
20736 
20737  argc = lua_gettop(L);
20738  if (argc == 2) {
20739  int _v;
20740  {
20741  void *ptr;
20742  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator, 0)) {
20743  _v = 0;
20744  } else {
20745  _v = 1;
20746  }
20747  }
20748  if (_v) {
20749  {
20750  void *ptr;
20751  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Attribute, 0)) {
20752  _v = 0;
20753  } else {
20754  _v = 1;
20755  }
20756  }
20757  if (_v) {
20758  return _wrap_NamedNodeIterator_RemoveAttribute__SWIG_0(L);
20759  }
20760  }
20761  }
20762  if (argc == 2) {
20763  int _v;
20764  {
20765  void *ptr;
20766  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator, 0)) {
20767  _v = 0;
20768  } else {
20769  _v = 1;
20770  }
20771  }
20772  if (_v) {
20773  {
20774  _v = SWIG_lua_isnilstring(L,argv[1]);
20775  }
20776  if (_v) {
20777  return _wrap_NamedNodeIterator_RemoveAttribute__SWIG_1(L);
20778  }
20779  }
20780  }
20781 
20782  lua_pushstring(L,"Wrong arguments for overloaded function 'NamedNodeIterator_RemoveAttribute'\n"
20783  " Possible C/C++ prototypes are:\n"
20784  " Mezzanine::XML::Node::RemoveAttribute(Mezzanine::XML::Attribute const &)\n"
20785  " Mezzanine::XML::Node::RemoveAttribute(Mezzanine::Char8 const *)\n");
20786  lua_error(L);return 0;
20787 }
20788 
20789 
20790 static int _wrap_NamedNodeIterator_RemoveChild__SWIG_0(lua_State* L) {
20791  int SWIG_arg = 0;
20793  Mezzanine::XML::Node *arg2 = 0 ;
20794  bool result;
20795 
20796  SWIG_check_num_args("Mezzanine::XML::Node::RemoveChild",2,2)
20797  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::RemoveChild",1,"Mezzanine::XML::NamedNodeIterator *");
20798  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::RemoveChild",2,"Mezzanine::XML::Node const &");
20799 
20800  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
20801  SWIG_fail_ptr("NamedNodeIterator_RemoveChild",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
20802  }
20803 
20804 
20805  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Node,0))){
20806  SWIG_fail_ptr("NamedNodeIterator_RemoveChild",2,SWIGTYPE_p_Mezzanine__XML__Node);
20807  }
20808 
20809  result = (bool)(*arg1)->RemoveChild((Mezzanine::XML::Node const &)*arg2);
20810  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
20811  return SWIG_arg;
20812 
20813  if(0) SWIG_fail;
20814 
20815 fail:
20816  lua_error(L);
20817  return SWIG_arg;
20818 }
20819 
20820 
20821 static int _wrap_NamedNodeIterator_RemoveChild__SWIG_1(lua_State* L) {
20822  int SWIG_arg = 0;
20824  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
20825  bool result;
20826 
20827  SWIG_check_num_args("Mezzanine::XML::Node::RemoveChild",2,2)
20828  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::RemoveChild",1,"Mezzanine::XML::NamedNodeIterator *");
20829  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::RemoveChild",2,"Mezzanine::Char8 const *");
20830 
20831  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
20832  SWIG_fail_ptr("NamedNodeIterator_RemoveChild",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
20833  }
20834 
20835  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
20836  result = (bool)(*arg1)->RemoveChild((Mezzanine::Char8 const *)arg2);
20837  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
20838  return SWIG_arg;
20839 
20840  if(0) SWIG_fail;
20841 
20842 fail:
20843  lua_error(L);
20844  return SWIG_arg;
20845 }
20846 
20847 
20848 static int _wrap_NamedNodeIterator_RemoveChild(lua_State* L) {
20849  int argc;
20850  int argv[3]={
20851  1,2,3
20852  };
20853 
20854  argc = lua_gettop(L);
20855  if (argc == 2) {
20856  int _v;
20857  {
20858  void *ptr;
20859  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator, 0)) {
20860  _v = 0;
20861  } else {
20862  _v = 1;
20863  }
20864  }
20865  if (_v) {
20866  {
20867  void *ptr;
20868  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
20869  _v = 0;
20870  } else {
20871  _v = 1;
20872  }
20873  }
20874  if (_v) {
20875  return _wrap_NamedNodeIterator_RemoveChild__SWIG_0(L);
20876  }
20877  }
20878  }
20879  if (argc == 2) {
20880  int _v;
20881  {
20882  void *ptr;
20883  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator, 0)) {
20884  _v = 0;
20885  } else {
20886  _v = 1;
20887  }
20888  }
20889  if (_v) {
20890  {
20891  _v = SWIG_lua_isnilstring(L,argv[1]);
20892  }
20893  if (_v) {
20894  return _wrap_NamedNodeIterator_RemoveChild__SWIG_1(L);
20895  }
20896  }
20897  }
20898 
20899  lua_pushstring(L,"Wrong arguments for overloaded function 'NamedNodeIterator_RemoveChild'\n"
20900  " Possible C/C++ prototypes are:\n"
20901  " Mezzanine::XML::Node::RemoveChild(Mezzanine::XML::Node const &)\n"
20902  " Mezzanine::XML::Node::RemoveChild(Mezzanine::Char8 const *)\n");
20903  lua_error(L);return 0;
20904 }
20905 
20906 
20907 static int _wrap_NamedNodeIterator_FindChildbyAttribute__SWIG_0(lua_State* L) {
20908  int SWIG_arg = 0;
20910  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
20911  Mezzanine::Char8 *arg3 = (Mezzanine::Char8 *) 0 ;
20912  Mezzanine::Char8 *arg4 = (Mezzanine::Char8 *) 0 ;
20913  Mezzanine::XML::Node result;
20914 
20915  SWIG_check_num_args("Mezzanine::XML::Node::FindChildbyAttribute",4,4)
20916  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::FindChildbyAttribute",1,"Mezzanine::XML::NamedNodeIterator const *");
20917  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::FindChildbyAttribute",2,"Mezzanine::Char8 const *");
20918  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::FindChildbyAttribute",3,"Mezzanine::Char8 const *");
20919  if(!SWIG_lua_isnilstring(L,4)) SWIG_fail_arg("Mezzanine::XML::Node::FindChildbyAttribute",4,"Mezzanine::Char8 const *");
20920 
20921  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
20922  SWIG_fail_ptr("NamedNodeIterator_FindChildbyAttribute",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
20923  }
20924 
20925  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
20926  arg3 = (Mezzanine::Char8 *)lua_tostring(L, 3);
20927  arg4 = (Mezzanine::Char8 *)lua_tostring(L, 4);
20928  result = (*arg1)->FindChildbyAttribute((Mezzanine::Char8 const *)arg2,(Mezzanine::Char8 const *)arg3,(Mezzanine::Char8 const *)arg4);
20929  {
20930  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
20931  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
20932  }
20933  return SWIG_arg;
20934 
20935  if(0) SWIG_fail;
20936 
20937 fail:
20938  lua_error(L);
20939  return SWIG_arg;
20940 }
20941 
20942 
20943 static int _wrap_NamedNodeIterator_FindChildbyAttribute__SWIG_1(lua_State* L) {
20944  int SWIG_arg = 0;
20946  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
20947  Mezzanine::Char8 *arg3 = (Mezzanine::Char8 *) 0 ;
20948  Mezzanine::XML::Node result;
20949 
20950  SWIG_check_num_args("Mezzanine::XML::Node::FindChildbyAttribute",3,3)
20951  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::FindChildbyAttribute",1,"Mezzanine::XML::NamedNodeIterator const *");
20952  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::FindChildbyAttribute",2,"Mezzanine::Char8 const *");
20953  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::FindChildbyAttribute",3,"Mezzanine::Char8 const *");
20954 
20955  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
20956  SWIG_fail_ptr("NamedNodeIterator_FindChildbyAttribute",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
20957  }
20958 
20959  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
20960  arg3 = (Mezzanine::Char8 *)lua_tostring(L, 3);
20961  result = (*arg1)->FindChildbyAttribute((Mezzanine::Char8 const *)arg2,(Mezzanine::Char8 const *)arg3);
20962  {
20963  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
20964  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
20965  }
20966  return SWIG_arg;
20967 
20968  if(0) SWIG_fail;
20969 
20970 fail:
20971  lua_error(L);
20972  return SWIG_arg;
20973 }
20974 
20975 
20976 static int _wrap_NamedNodeIterator_FindChildbyAttribute(lua_State* L) {
20977  int argc;
20978  int argv[5]={
20979  1,2,3,4,5
20980  };
20981 
20982  argc = lua_gettop(L);
20983  if (argc == 3) {
20984  int _v;
20985  {
20986  void *ptr;
20987  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator, 0)) {
20988  _v = 0;
20989  } else {
20990  _v = 1;
20991  }
20992  }
20993  if (_v) {
20994  {
20995  _v = SWIG_lua_isnilstring(L,argv[1]);
20996  }
20997  if (_v) {
20998  {
20999  _v = SWIG_lua_isnilstring(L,argv[2]);
21000  }
21001  if (_v) {
21002  return _wrap_NamedNodeIterator_FindChildbyAttribute__SWIG_1(L);
21003  }
21004  }
21005  }
21006  }
21007  if (argc == 4) {
21008  int _v;
21009  {
21010  void *ptr;
21011  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator, 0)) {
21012  _v = 0;
21013  } else {
21014  _v = 1;
21015  }
21016  }
21017  if (_v) {
21018  {
21019  _v = SWIG_lua_isnilstring(L,argv[1]);
21020  }
21021  if (_v) {
21022  {
21023  _v = SWIG_lua_isnilstring(L,argv[2]);
21024  }
21025  if (_v) {
21026  {
21027  _v = SWIG_lua_isnilstring(L,argv[3]);
21028  }
21029  if (_v) {
21030  return _wrap_NamedNodeIterator_FindChildbyAttribute__SWIG_0(L);
21031  }
21032  }
21033  }
21034  }
21035  }
21036 
21037  lua_pushstring(L,"Wrong arguments for overloaded function 'NamedNodeIterator_FindChildbyAttribute'\n"
21038  " Possible C/C++ prototypes are:\n"
21039  " Mezzanine::XML::Node::FindChildbyAttribute(Mezzanine::Char8 const *,Mezzanine::Char8 const *,Mezzanine::Char8 const *) const\n"
21040  " Mezzanine::XML::Node::FindChildbyAttribute(Mezzanine::Char8 const *,Mezzanine::Char8 const *) const\n");
21041  lua_error(L);return 0;
21042 }
21043 
21044 
21045 static int _wrap_NamedNodeIterator_Path__SWIG_0(lua_State* L) {
21046  int SWIG_arg = 0;
21048  Mezzanine::Char8 arg2 ;
21049  Mezzanine::String result;
21050 
21051  SWIG_check_num_args("Mezzanine::XML::Node::Path",2,2)
21052  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Path",1,"Mezzanine::XML::NamedNodeIterator const *");
21053  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::Path",2,"Mezzanine::Char8");
21054 
21055  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
21056  SWIG_fail_ptr("NamedNodeIterator_Path",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
21057  }
21058 
21059  arg2 = (lua_tostring(L, 2))[0];
21060  result = (*arg1)->Path(arg2);
21061  lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
21062  return SWIG_arg;
21063 
21064  if(0) SWIG_fail;
21065 
21066 fail:
21067  lua_error(L);
21068  return SWIG_arg;
21069 }
21070 
21071 
21072 static int _wrap_NamedNodeIterator_Path__SWIG_1(lua_State* L) {
21073  int SWIG_arg = 0;
21075  Mezzanine::String result;
21076 
21077  SWIG_check_num_args("Mezzanine::XML::Node::Path",1,1)
21078  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Path",1,"Mezzanine::XML::NamedNodeIterator const *");
21079 
21080  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
21081  SWIG_fail_ptr("NamedNodeIterator_Path",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
21082  }
21083 
21084  result = (*arg1)->Path();
21085  lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
21086  return SWIG_arg;
21087 
21088  if(0) SWIG_fail;
21089 
21090 fail:
21091  lua_error(L);
21092  return SWIG_arg;
21093 }
21094 
21095 
21096 static int _wrap_NamedNodeIterator_Path(lua_State* L) {
21097  int argc;
21098  int argv[3]={
21099  1,2,3
21100  };
21101 
21102  argc = lua_gettop(L);
21103  if (argc == 1) {
21104  int _v;
21105  {
21106  void *ptr;
21107  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator, 0)) {
21108  _v = 0;
21109  } else {
21110  _v = 1;
21111  }
21112  }
21113  if (_v) {
21114  return _wrap_NamedNodeIterator_Path__SWIG_1(L);
21115  }
21116  }
21117  if (argc == 2) {
21118  int _v;
21119  {
21120  void *ptr;
21121  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator, 0)) {
21122  _v = 0;
21123  } else {
21124  _v = 1;
21125  }
21126  }
21127  if (_v) {
21128  {
21129  _v = SWIG_lua_isnilstring(L,argv[1]) && (lua_rawlen(L,argv[1])==1);
21130  }
21131  if (_v) {
21132  return _wrap_NamedNodeIterator_Path__SWIG_0(L);
21133  }
21134  }
21135  }
21136 
21137  lua_pushstring(L,"Wrong arguments for overloaded function 'NamedNodeIterator_Path'\n"
21138  " Possible C/C++ prototypes are:\n"
21139  " Mezzanine::XML::Node::Path(Mezzanine::Char8) const\n"
21140  " Mezzanine::XML::Node::Path() const\n");
21141  lua_error(L);return 0;
21142 }
21143 
21144 
21145 static int _wrap_NamedNodeIterator_FirstElementByPath__SWIG_0(lua_State* L) {
21146  int SWIG_arg = 0;
21148  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
21149  Mezzanine::Char8 arg3 ;
21150  Mezzanine::XML::Node result;
21151 
21152  SWIG_check_num_args("Mezzanine::XML::Node::FirstElementByPath",3,3)
21153  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::FirstElementByPath",1,"Mezzanine::XML::NamedNodeIterator const *");
21154  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::FirstElementByPath",2,"Mezzanine::Char8 const *");
21155  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::FirstElementByPath",3,"Mezzanine::Char8");
21156 
21157  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
21158  SWIG_fail_ptr("NamedNodeIterator_FirstElementByPath",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
21159  }
21160 
21161  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
21162  arg3 = (lua_tostring(L, 3))[0];
21163  result = (*arg1)->FirstElementByPath((Mezzanine::Char8 const *)arg2,arg3);
21164  {
21165  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
21166  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
21167  }
21168  return SWIG_arg;
21169 
21170  if(0) SWIG_fail;
21171 
21172 fail:
21173  lua_error(L);
21174  return SWIG_arg;
21175 }
21176 
21177 
21178 static int _wrap_NamedNodeIterator_FirstElementByPath__SWIG_1(lua_State* L) {
21179  int SWIG_arg = 0;
21181  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
21182  Mezzanine::XML::Node result;
21183 
21184  SWIG_check_num_args("Mezzanine::XML::Node::FirstElementByPath",2,2)
21185  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::FirstElementByPath",1,"Mezzanine::XML::NamedNodeIterator const *");
21186  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::FirstElementByPath",2,"Mezzanine::Char8 const *");
21187 
21188  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
21189  SWIG_fail_ptr("NamedNodeIterator_FirstElementByPath",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
21190  }
21191 
21192  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
21193  result = (*arg1)->FirstElementByPath((Mezzanine::Char8 const *)arg2);
21194  {
21195  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
21196  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
21197  }
21198  return SWIG_arg;
21199 
21200  if(0) SWIG_fail;
21201 
21202 fail:
21203  lua_error(L);
21204  return SWIG_arg;
21205 }
21206 
21207 
21208 static int _wrap_NamedNodeIterator_FirstElementByPath(lua_State* L) {
21209  int argc;
21210  int argv[4]={
21211  1,2,3,4
21212  };
21213 
21214  argc = lua_gettop(L);
21215  if (argc == 2) {
21216  int _v;
21217  {
21218  void *ptr;
21219  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator, 0)) {
21220  _v = 0;
21221  } else {
21222  _v = 1;
21223  }
21224  }
21225  if (_v) {
21226  {
21227  _v = SWIG_lua_isnilstring(L,argv[1]);
21228  }
21229  if (_v) {
21230  return _wrap_NamedNodeIterator_FirstElementByPath__SWIG_1(L);
21231  }
21232  }
21233  }
21234  if (argc == 3) {
21235  int _v;
21236  {
21237  void *ptr;
21238  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator, 0)) {
21239  _v = 0;
21240  } else {
21241  _v = 1;
21242  }
21243  }
21244  if (_v) {
21245  {
21246  _v = SWIG_lua_isnilstring(L,argv[1]);
21247  }
21248  if (_v) {
21249  {
21250  _v = SWIG_lua_isnilstring(L,argv[2]) && (lua_rawlen(L,argv[2])==1);
21251  }
21252  if (_v) {
21253  return _wrap_NamedNodeIterator_FirstElementByPath__SWIG_0(L);
21254  }
21255  }
21256  }
21257  }
21258 
21259  lua_pushstring(L,"Wrong arguments for overloaded function 'NamedNodeIterator_FirstElementByPath'\n"
21260  " Possible C/C++ prototypes are:\n"
21261  " Mezzanine::XML::Node::FirstElementByPath(Mezzanine::Char8 const *,Mezzanine::Char8) const\n"
21262  " Mezzanine::XML::Node::FirstElementByPath(Mezzanine::Char8 const *) const\n");
21263  lua_error(L);return 0;
21264 }
21265 
21266 
21267 static int _wrap_NamedNodeIterator_Traverse(lua_State* L) {
21268  int SWIG_arg = 0;
21270  Mezzanine::XML::TreeWalker *arg2 = 0 ;
21271  bool result;
21272 
21273  SWIG_check_num_args("Mezzanine::XML::Node::Traverse",2,2)
21274  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Traverse",1,"Mezzanine::XML::NamedNodeIterator *");
21275  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::Traverse",2,"Mezzanine::XML::TreeWalker &");
21276 
21277  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
21278  SWIG_fail_ptr("NamedNodeIterator_Traverse",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
21279  }
21280 
21281 
21282  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__TreeWalker,0))){
21283  SWIG_fail_ptr("NamedNodeIterator_Traverse",2,SWIGTYPE_p_Mezzanine__XML__TreeWalker);
21284  }
21285 
21286  result = (bool)(*arg1)->Traverse(*arg2);
21287  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
21288  return SWIG_arg;
21289 
21290  if(0) SWIG_fail;
21291 
21292 fail:
21293  lua_error(L);
21294  return SWIG_arg;
21295 }
21296 
21297 
21298 static int _wrap_NamedNodeIterator_FindSingleNode__SWIG_0(lua_State* L) {
21299  int SWIG_arg = 0;
21301  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
21304 
21305  SWIG_check_num_args("Mezzanine::XML::Node::FindSingleNode",3,3)
21306  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::FindSingleNode",1,"Mezzanine::XML::NamedNodeIterator const *");
21307  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::FindSingleNode",2,"Mezzanine::Char8 const *");
21308  if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::FindSingleNode",3,"Mezzanine::XML::XPathVariableSet *");
21309 
21310  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
21311  SWIG_fail_ptr("NamedNodeIterator_FindSingleNode",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
21312  }
21313 
21314  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
21315 
21316  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__XML__XPathVariableSet,0))){
21317  SWIG_fail_ptr("NamedNodeIterator_FindSingleNode",3,SWIGTYPE_p_Mezzanine__XML__XPathVariableSet);
21318  }
21319 
21320  result = (*arg1)->FindSingleNode((Mezzanine::Char8 const *)arg2,arg3);
21321  {
21323  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__XPathNode,1); SWIG_arg++;
21324  }
21325  return SWIG_arg;
21326 
21327  if(0) SWIG_fail;
21328 
21329 fail:
21330  lua_error(L);
21331  return SWIG_arg;
21332 }
21333 
21334 
21335 static int _wrap_NamedNodeIterator_FindSingleNode__SWIG_1(lua_State* L) {
21336  int SWIG_arg = 0;
21338  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
21340 
21341  SWIG_check_num_args("Mezzanine::XML::Node::FindSingleNode",2,2)
21342  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::FindSingleNode",1,"Mezzanine::XML::NamedNodeIterator const *");
21343  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::FindSingleNode",2,"Mezzanine::Char8 const *");
21344 
21345  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
21346  SWIG_fail_ptr("NamedNodeIterator_FindSingleNode",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
21347  }
21348 
21349  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
21350  result = (*arg1)->FindSingleNode((Mezzanine::Char8 const *)arg2);
21351  {
21353  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__XPathNode,1); SWIG_arg++;
21354  }
21355  return SWIG_arg;
21356 
21357  if(0) SWIG_fail;
21358 
21359 fail:
21360  lua_error(L);
21361  return SWIG_arg;
21362 }
21363 
21364 
21365 static int _wrap_NamedNodeIterator_FindSingleNode__SWIG_2(lua_State* L) {
21366  int SWIG_arg = 0;
21368  Mezzanine::XML::XPathQuery *arg2 = 0 ;
21370 
21371  SWIG_check_num_args("Mezzanine::XML::Node::FindSingleNode",2,2)
21372  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::FindSingleNode",1,"Mezzanine::XML::NamedNodeIterator const *");
21373  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::FindSingleNode",2,"Mezzanine::XML::XPathQuery const &");
21374 
21375  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
21376  SWIG_fail_ptr("NamedNodeIterator_FindSingleNode",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
21377  }
21378 
21379 
21380  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__XPathQuery,0))){
21381  SWIG_fail_ptr("NamedNodeIterator_FindSingleNode",2,SWIGTYPE_p_Mezzanine__XML__XPathQuery);
21382  }
21383 
21384  result = (*arg1)->FindSingleNode((Mezzanine::XML::XPathQuery const &)*arg2);
21385  {
21387  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__XPathNode,1); SWIG_arg++;
21388  }
21389  return SWIG_arg;
21390 
21391  if(0) SWIG_fail;
21392 
21393 fail:
21394  lua_error(L);
21395  return SWIG_arg;
21396 }
21397 
21398 
21399 static int _wrap_NamedNodeIterator_FindSingleNode(lua_State* L) {
21400  int argc;
21401  int argv[4]={
21402  1,2,3,4
21403  };
21404 
21405  argc = lua_gettop(L);
21406  if (argc == 2) {
21407  int _v;
21408  {
21409  void *ptr;
21410  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator, 0)) {
21411  _v = 0;
21412  } else {
21413  _v = 1;
21414  }
21415  }
21416  if (_v) {
21417  {
21418  void *ptr;
21419  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__XPathQuery, 0)) {
21420  _v = 0;
21421  } else {
21422  _v = 1;
21423  }
21424  }
21425  if (_v) {
21426  return _wrap_NamedNodeIterator_FindSingleNode__SWIG_2(L);
21427  }
21428  }
21429  }
21430  if (argc == 2) {
21431  int _v;
21432  {
21433  void *ptr;
21434  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator, 0)) {
21435  _v = 0;
21436  } else {
21437  _v = 1;
21438  }
21439  }
21440  if (_v) {
21441  {
21442  _v = SWIG_lua_isnilstring(L,argv[1]);
21443  }
21444  if (_v) {
21445  return _wrap_NamedNodeIterator_FindSingleNode__SWIG_1(L);
21446  }
21447  }
21448  }
21449  if (argc == 3) {
21450  int _v;
21451  {
21452  void *ptr;
21453  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator, 0)) {
21454  _v = 0;
21455  } else {
21456  _v = 1;
21457  }
21458  }
21459  if (_v) {
21460  {
21461  _v = SWIG_lua_isnilstring(L,argv[1]);
21462  }
21463  if (_v) {
21464  {
21465  void *ptr;
21466  if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__XPathVariableSet, 0)) {
21467  _v = 0;
21468  } else {
21469  _v = 1;
21470  }
21471  }
21472  if (_v) {
21473  return _wrap_NamedNodeIterator_FindSingleNode__SWIG_0(L);
21474  }
21475  }
21476  }
21477  }
21478 
21479  lua_pushstring(L,"Wrong arguments for overloaded function 'NamedNodeIterator_FindSingleNode'\n"
21480  " Possible C/C++ prototypes are:\n"
21481  " Mezzanine::XML::Node::FindSingleNode(Mezzanine::Char8 const *,Mezzanine::XML::XPathVariableSet *) const\n"
21482  " Mezzanine::XML::Node::FindSingleNode(Mezzanine::Char8 const *) const\n"
21483  " Mezzanine::XML::Node::FindSingleNode(Mezzanine::XML::XPathQuery const &) const\n");
21484  lua_error(L);return 0;
21485 }
21486 
21487 
21488 static int _wrap_NamedNodeIterator_FindNodes__SWIG_0(lua_State* L) {
21489  int SWIG_arg = 0;
21491  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
21494 
21495  SWIG_check_num_args("Mezzanine::XML::Node::FindNodes",3,3)
21496  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::FindNodes",1,"Mezzanine::XML::NamedNodeIterator const *");
21497  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::FindNodes",2,"Mezzanine::Char8 const *");
21498  if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::FindNodes",3,"Mezzanine::XML::XPathVariableSet *");
21499 
21500  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
21501  SWIG_fail_ptr("NamedNodeIterator_FindNodes",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
21502  }
21503 
21504  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
21505 
21506  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__XML__XPathVariableSet,0))){
21507  SWIG_fail_ptr("NamedNodeIterator_FindNodes",3,SWIGTYPE_p_Mezzanine__XML__XPathVariableSet);
21508  }
21509 
21510  result = (*arg1)->FindNodes((Mezzanine::Char8 const *)arg2,arg3);
21511  {
21513  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__XPathNodeSet,1); SWIG_arg++;
21514  }
21515  return SWIG_arg;
21516 
21517  if(0) SWIG_fail;
21518 
21519 fail:
21520  lua_error(L);
21521  return SWIG_arg;
21522 }
21523 
21524 
21525 static int _wrap_NamedNodeIterator_FindNodes__SWIG_1(lua_State* L) {
21526  int SWIG_arg = 0;
21528  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
21530 
21531  SWIG_check_num_args("Mezzanine::XML::Node::FindNodes",2,2)
21532  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::FindNodes",1,"Mezzanine::XML::NamedNodeIterator const *");
21533  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::FindNodes",2,"Mezzanine::Char8 const *");
21534 
21535  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
21536  SWIG_fail_ptr("NamedNodeIterator_FindNodes",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
21537  }
21538 
21539  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
21540  result = (*arg1)->FindNodes((Mezzanine::Char8 const *)arg2);
21541  {
21543  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__XPathNodeSet,1); SWIG_arg++;
21544  }
21545  return SWIG_arg;
21546 
21547  if(0) SWIG_fail;
21548 
21549 fail:
21550  lua_error(L);
21551  return SWIG_arg;
21552 }
21553 
21554 
21555 static int _wrap_NamedNodeIterator_FindNodes__SWIG_2(lua_State* L) {
21556  int SWIG_arg = 0;
21558  Mezzanine::XML::XPathQuery *arg2 = 0 ;
21560 
21561  SWIG_check_num_args("Mezzanine::XML::Node::FindNodes",2,2)
21562  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::FindNodes",1,"Mezzanine::XML::NamedNodeIterator const *");
21563  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::FindNodes",2,"Mezzanine::XML::XPathQuery const &");
21564 
21565  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
21566  SWIG_fail_ptr("NamedNodeIterator_FindNodes",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
21567  }
21568 
21569 
21570  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__XPathQuery,0))){
21571  SWIG_fail_ptr("NamedNodeIterator_FindNodes",2,SWIGTYPE_p_Mezzanine__XML__XPathQuery);
21572  }
21573 
21574  result = (*arg1)->FindNodes((Mezzanine::XML::XPathQuery const &)*arg2);
21575  {
21577  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__XPathNodeSet,1); SWIG_arg++;
21578  }
21579  return SWIG_arg;
21580 
21581  if(0) SWIG_fail;
21582 
21583 fail:
21584  lua_error(L);
21585  return SWIG_arg;
21586 }
21587 
21588 
21589 static int _wrap_NamedNodeIterator_FindNodes(lua_State* L) {
21590  int argc;
21591  int argv[4]={
21592  1,2,3,4
21593  };
21594 
21595  argc = lua_gettop(L);
21596  if (argc == 2) {
21597  int _v;
21598  {
21599  void *ptr;
21600  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator, 0)) {
21601  _v = 0;
21602  } else {
21603  _v = 1;
21604  }
21605  }
21606  if (_v) {
21607  {
21608  void *ptr;
21609  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__XPathQuery, 0)) {
21610  _v = 0;
21611  } else {
21612  _v = 1;
21613  }
21614  }
21615  if (_v) {
21616  return _wrap_NamedNodeIterator_FindNodes__SWIG_2(L);
21617  }
21618  }
21619  }
21620  if (argc == 2) {
21621  int _v;
21622  {
21623  void *ptr;
21624  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator, 0)) {
21625  _v = 0;
21626  } else {
21627  _v = 1;
21628  }
21629  }
21630  if (_v) {
21631  {
21632  _v = SWIG_lua_isnilstring(L,argv[1]);
21633  }
21634  if (_v) {
21635  return _wrap_NamedNodeIterator_FindNodes__SWIG_1(L);
21636  }
21637  }
21638  }
21639  if (argc == 3) {
21640  int _v;
21641  {
21642  void *ptr;
21643  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator, 0)) {
21644  _v = 0;
21645  } else {
21646  _v = 1;
21647  }
21648  }
21649  if (_v) {
21650  {
21651  _v = SWIG_lua_isnilstring(L,argv[1]);
21652  }
21653  if (_v) {
21654  {
21655  void *ptr;
21656  if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__XPathVariableSet, 0)) {
21657  _v = 0;
21658  } else {
21659  _v = 1;
21660  }
21661  }
21662  if (_v) {
21663  return _wrap_NamedNodeIterator_FindNodes__SWIG_0(L);
21664  }
21665  }
21666  }
21667  }
21668 
21669  lua_pushstring(L,"Wrong arguments for overloaded function 'NamedNodeIterator_FindNodes'\n"
21670  " Possible C/C++ prototypes are:\n"
21671  " Mezzanine::XML::Node::FindNodes(Mezzanine::Char8 const *,Mezzanine::XML::XPathVariableSet *) const\n"
21672  " Mezzanine::XML::Node::FindNodes(Mezzanine::Char8 const *) const\n"
21673  " Mezzanine::XML::Node::FindNodes(Mezzanine::XML::XPathQuery const &) const\n");
21674  lua_error(L);return 0;
21675 }
21676 
21677 
21678 static int _wrap_NamedNodeIterator_Print__SWIG_0(lua_State* L) {
21679  int SWIG_arg = 0;
21681  Mezzanine::XML::Writer *arg2 = 0 ;
21682  Mezzanine::Char8 *arg3 = (Mezzanine::Char8 *) 0 ;
21683  unsigned int arg4 ;
21685  unsigned int arg6 ;
21686 
21687  SWIG_check_num_args("Mezzanine::XML::Node::Print",6,6)
21688  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Print",1,"Mezzanine::XML::NamedNodeIterator const *");
21689  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::Print",2,"Mezzanine::XML::Writer &");
21690  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::Print",3,"Mezzanine::Char8 const *");
21691  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::XML::Node::Print",4,"unsigned int");
21692  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::XML::Node::Print",5,"Mezzanine::XML::Encoding");
21693  if(!lua_isnumber(L,6)) SWIG_fail_arg("Mezzanine::XML::Node::Print",6,"unsigned int");
21694 
21695  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
21696  SWIG_fail_ptr("NamedNodeIterator_Print",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
21697  }
21698 
21699 
21700  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Writer,0))){
21701  SWIG_fail_ptr("NamedNodeIterator_Print",2,SWIGTYPE_p_Mezzanine__XML__Writer);
21702  }
21703 
21704  arg3 = (Mezzanine::Char8 *)lua_tostring(L, 3);
21705  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
21706  arg4 = (unsigned int)lua_tonumber(L, 4);
21707  arg5 = (Mezzanine::XML::Encoding)(int)lua_tonumber(L, 5);
21708  SWIG_contract_assert((lua_tonumber(L,6)>=0),"number must not be negative")
21709  arg6 = (unsigned int)lua_tonumber(L, 6);
21710  (*arg1)->Print(*arg2,(Mezzanine::Char8 const *)arg3,arg4,arg5,arg6);
21711 
21712  return SWIG_arg;
21713 
21714  if(0) SWIG_fail;
21715 
21716 fail:
21717  lua_error(L);
21718  return SWIG_arg;
21719 }
21720 
21721 
21722 static int _wrap_NamedNodeIterator_Print__SWIG_1(lua_State* L) {
21723  int SWIG_arg = 0;
21725  Mezzanine::XML::Writer *arg2 = 0 ;
21726  Mezzanine::Char8 *arg3 = (Mezzanine::Char8 *) 0 ;
21727  unsigned int arg4 ;
21729 
21730  SWIG_check_num_args("Mezzanine::XML::Node::Print",5,5)
21731  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Print",1,"Mezzanine::XML::NamedNodeIterator const *");
21732  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::Print",2,"Mezzanine::XML::Writer &");
21733  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::Print",3,"Mezzanine::Char8 const *");
21734  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::XML::Node::Print",4,"unsigned int");
21735  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::XML::Node::Print",5,"Mezzanine::XML::Encoding");
21736 
21737  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
21738  SWIG_fail_ptr("NamedNodeIterator_Print",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
21739  }
21740 
21741 
21742  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Writer,0))){
21743  SWIG_fail_ptr("NamedNodeIterator_Print",2,SWIGTYPE_p_Mezzanine__XML__Writer);
21744  }
21745 
21746  arg3 = (Mezzanine::Char8 *)lua_tostring(L, 3);
21747  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
21748  arg4 = (unsigned int)lua_tonumber(L, 4);
21749  arg5 = (Mezzanine::XML::Encoding)(int)lua_tonumber(L, 5);
21750  (*arg1)->Print(*arg2,(Mezzanine::Char8 const *)arg3,arg4,arg5);
21751 
21752  return SWIG_arg;
21753 
21754  if(0) SWIG_fail;
21755 
21756 fail:
21757  lua_error(L);
21758  return SWIG_arg;
21759 }
21760 
21761 
21762 static int _wrap_NamedNodeIterator_Print__SWIG_2(lua_State* L) {
21763  int SWIG_arg = 0;
21765  Mezzanine::XML::Writer *arg2 = 0 ;
21766  Mezzanine::Char8 *arg3 = (Mezzanine::Char8 *) 0 ;
21767  unsigned int arg4 ;
21768 
21769  SWIG_check_num_args("Mezzanine::XML::Node::Print",4,4)
21770  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Print",1,"Mezzanine::XML::NamedNodeIterator const *");
21771  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::Print",2,"Mezzanine::XML::Writer &");
21772  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::Print",3,"Mezzanine::Char8 const *");
21773  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::XML::Node::Print",4,"unsigned int");
21774 
21775  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
21776  SWIG_fail_ptr("NamedNodeIterator_Print",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
21777  }
21778 
21779 
21780  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Writer,0))){
21781  SWIG_fail_ptr("NamedNodeIterator_Print",2,SWIGTYPE_p_Mezzanine__XML__Writer);
21782  }
21783 
21784  arg3 = (Mezzanine::Char8 *)lua_tostring(L, 3);
21785  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
21786  arg4 = (unsigned int)lua_tonumber(L, 4);
21787  (*arg1)->Print(*arg2,(Mezzanine::Char8 const *)arg3,arg4);
21788 
21789  return SWIG_arg;
21790 
21791  if(0) SWIG_fail;
21792 
21793 fail:
21794  lua_error(L);
21795  return SWIG_arg;
21796 }
21797 
21798 
21799 static int _wrap_NamedNodeIterator_Print__SWIG_3(lua_State* L) {
21800  int SWIG_arg = 0;
21802  Mezzanine::XML::Writer *arg2 = 0 ;
21803  Mezzanine::Char8 *arg3 = (Mezzanine::Char8 *) 0 ;
21804 
21805  SWIG_check_num_args("Mezzanine::XML::Node::Print",3,3)
21806  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Print",1,"Mezzanine::XML::NamedNodeIterator const *");
21807  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::Print",2,"Mezzanine::XML::Writer &");
21808  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::Print",3,"Mezzanine::Char8 const *");
21809 
21810  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
21811  SWIG_fail_ptr("NamedNodeIterator_Print",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
21812  }
21813 
21814 
21815  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Writer,0))){
21816  SWIG_fail_ptr("NamedNodeIterator_Print",2,SWIGTYPE_p_Mezzanine__XML__Writer);
21817  }
21818 
21819  arg3 = (Mezzanine::Char8 *)lua_tostring(L, 3);
21820  (*arg1)->Print(*arg2,(Mezzanine::Char8 const *)arg3);
21821 
21822  return SWIG_arg;
21823 
21824  if(0) SWIG_fail;
21825 
21826 fail:
21827  lua_error(L);
21828  return SWIG_arg;
21829 }
21830 
21831 
21832 static int _wrap_NamedNodeIterator_Print__SWIG_4(lua_State* L) {
21833  int SWIG_arg = 0;
21835  Mezzanine::XML::Writer *arg2 = 0 ;
21836 
21837  SWIG_check_num_args("Mezzanine::XML::Node::Print",2,2)
21838  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Print",1,"Mezzanine::XML::NamedNodeIterator const *");
21839  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::Print",2,"Mezzanine::XML::Writer &");
21840 
21841  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
21842  SWIG_fail_ptr("NamedNodeIterator_Print",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
21843  }
21844 
21845 
21846  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Writer,0))){
21847  SWIG_fail_ptr("NamedNodeIterator_Print",2,SWIGTYPE_p_Mezzanine__XML__Writer);
21848  }
21849 
21850  (*arg1)->Print(*arg2);
21851 
21852  return SWIG_arg;
21853 
21854  if(0) SWIG_fail;
21855 
21856 fail:
21857  lua_error(L);
21858  return SWIG_arg;
21859 }
21860 
21861 
21862 static int _wrap_NamedNodeIterator_Print__SWIG_5(lua_State* L) {
21863  int SWIG_arg = 0;
21865  std::basic_ostream< char,std::char_traits< char > > *arg2 = 0 ;
21866  Mezzanine::Char8 *arg3 = (Mezzanine::Char8 *) 0 ;
21867  unsigned int arg4 ;
21869  unsigned int arg6 ;
21870 
21871  SWIG_check_num_args("Mezzanine::XML::Node::Print",6,6)
21872  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Print",1,"Mezzanine::XML::NamedNodeIterator const *");
21873  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::Print",2,"std::basic_ostream< char,std::char_traits< char > > &");
21874  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::Print",3,"Mezzanine::Char8 const *");
21875  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::XML::Node::Print",4,"unsigned int");
21876  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::XML::Node::Print",5,"Mezzanine::XML::Encoding");
21877  if(!lua_isnumber(L,6)) SWIG_fail_arg("Mezzanine::XML::Node::Print",6,"unsigned int");
21878 
21879  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
21880  SWIG_fail_ptr("NamedNodeIterator_Print",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
21881  }
21882 
21883 
21884  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,0))){
21885  SWIG_fail_ptr("NamedNodeIterator_Print",2,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t);
21886  }
21887 
21888  arg3 = (Mezzanine::Char8 *)lua_tostring(L, 3);
21889  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
21890  arg4 = (unsigned int)lua_tonumber(L, 4);
21891  arg5 = (Mezzanine::XML::Encoding)(int)lua_tonumber(L, 5);
21892  SWIG_contract_assert((lua_tonumber(L,6)>=0),"number must not be negative")
21893  arg6 = (unsigned int)lua_tonumber(L, 6);
21894  (*arg1)->Print(*arg2,(Mezzanine::Char8 const *)arg3,arg4,arg5,arg6);
21895 
21896  return SWIG_arg;
21897 
21898  if(0) SWIG_fail;
21899 
21900 fail:
21901  lua_error(L);
21902  return SWIG_arg;
21903 }
21904 
21905 
21906 static int _wrap_NamedNodeIterator_Print__SWIG_6(lua_State* L) {
21907  int SWIG_arg = 0;
21909  std::basic_ostream< char,std::char_traits< char > > *arg2 = 0 ;
21910  Mezzanine::Char8 *arg3 = (Mezzanine::Char8 *) 0 ;
21911  unsigned int arg4 ;
21913 
21914  SWIG_check_num_args("Mezzanine::XML::Node::Print",5,5)
21915  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Print",1,"Mezzanine::XML::NamedNodeIterator const *");
21916  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::Print",2,"std::basic_ostream< char,std::char_traits< char > > &");
21917  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::Print",3,"Mezzanine::Char8 const *");
21918  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::XML::Node::Print",4,"unsigned int");
21919  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::XML::Node::Print",5,"Mezzanine::XML::Encoding");
21920 
21921  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
21922  SWIG_fail_ptr("NamedNodeIterator_Print",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
21923  }
21924 
21925 
21926  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,0))){
21927  SWIG_fail_ptr("NamedNodeIterator_Print",2,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t);
21928  }
21929 
21930  arg3 = (Mezzanine::Char8 *)lua_tostring(L, 3);
21931  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
21932  arg4 = (unsigned int)lua_tonumber(L, 4);
21933  arg5 = (Mezzanine::XML::Encoding)(int)lua_tonumber(L, 5);
21934  (*arg1)->Print(*arg2,(Mezzanine::Char8 const *)arg3,arg4,arg5);
21935 
21936  return SWIG_arg;
21937 
21938  if(0) SWIG_fail;
21939 
21940 fail:
21941  lua_error(L);
21942  return SWIG_arg;
21943 }
21944 
21945 
21946 static int _wrap_NamedNodeIterator_Print__SWIG_7(lua_State* L) {
21947  int SWIG_arg = 0;
21949  std::basic_ostream< char,std::char_traits< char > > *arg2 = 0 ;
21950  Mezzanine::Char8 *arg3 = (Mezzanine::Char8 *) 0 ;
21951  unsigned int arg4 ;
21952 
21953  SWIG_check_num_args("Mezzanine::XML::Node::Print",4,4)
21954  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Print",1,"Mezzanine::XML::NamedNodeIterator const *");
21955  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::Print",2,"std::basic_ostream< char,std::char_traits< char > > &");
21956  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::Print",3,"Mezzanine::Char8 const *");
21957  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::XML::Node::Print",4,"unsigned int");
21958 
21959  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
21960  SWIG_fail_ptr("NamedNodeIterator_Print",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
21961  }
21962 
21963 
21964  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,0))){
21965  SWIG_fail_ptr("NamedNodeIterator_Print",2,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t);
21966  }
21967 
21968  arg3 = (Mezzanine::Char8 *)lua_tostring(L, 3);
21969  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
21970  arg4 = (unsigned int)lua_tonumber(L, 4);
21971  (*arg1)->Print(*arg2,(Mezzanine::Char8 const *)arg3,arg4);
21972 
21973  return SWIG_arg;
21974 
21975  if(0) SWIG_fail;
21976 
21977 fail:
21978  lua_error(L);
21979  return SWIG_arg;
21980 }
21981 
21982 
21983 static int _wrap_NamedNodeIterator_Print__SWIG_8(lua_State* L) {
21984  int SWIG_arg = 0;
21986  std::basic_ostream< char,std::char_traits< char > > *arg2 = 0 ;
21987  Mezzanine::Char8 *arg3 = (Mezzanine::Char8 *) 0 ;
21988 
21989  SWIG_check_num_args("Mezzanine::XML::Node::Print",3,3)
21990  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Print",1,"Mezzanine::XML::NamedNodeIterator const *");
21991  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::Print",2,"std::basic_ostream< char,std::char_traits< char > > &");
21992  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::Print",3,"Mezzanine::Char8 const *");
21993 
21994  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
21995  SWIG_fail_ptr("NamedNodeIterator_Print",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
21996  }
21997 
21998 
21999  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,0))){
22000  SWIG_fail_ptr("NamedNodeIterator_Print",2,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t);
22001  }
22002 
22003  arg3 = (Mezzanine::Char8 *)lua_tostring(L, 3);
22004  (*arg1)->Print(*arg2,(Mezzanine::Char8 const *)arg3);
22005 
22006  return SWIG_arg;
22007 
22008  if(0) SWIG_fail;
22009 
22010 fail:
22011  lua_error(L);
22012  return SWIG_arg;
22013 }
22014 
22015 
22016 static int _wrap_NamedNodeIterator_Print__SWIG_9(lua_State* L) {
22017  int SWIG_arg = 0;
22019  std::basic_ostream< char,std::char_traits< char > > *arg2 = 0 ;
22020 
22021  SWIG_check_num_args("Mezzanine::XML::Node::Print",2,2)
22022  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Print",1,"Mezzanine::XML::NamedNodeIterator const *");
22023  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::Print",2,"std::basic_ostream< char,std::char_traits< char > > &");
22024 
22025  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
22026  SWIG_fail_ptr("NamedNodeIterator_Print",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
22027  }
22028 
22029 
22030  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,0))){
22031  SWIG_fail_ptr("NamedNodeIterator_Print",2,SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t);
22032  }
22033 
22034  (*arg1)->Print(*arg2);
22035 
22036  return SWIG_arg;
22037 
22038  if(0) SWIG_fail;
22039 
22040 fail:
22041  lua_error(L);
22042  return SWIG_arg;
22043 }
22044 
22045 
22046 static int _wrap_NamedNodeIterator_Print__SWIG_10(lua_State* L) {
22047  int SWIG_arg = 0;
22049  std::basic_ostream< wchar_t,std::char_traits< wchar_t > > *arg2 = 0 ;
22050  Mezzanine::Char8 *arg3 = (Mezzanine::Char8 *) 0 ;
22051  unsigned int arg4 ;
22052  unsigned int arg5 ;
22053 
22054  SWIG_check_num_args("Mezzanine::XML::Node::Print",5,5)
22055  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Print",1,"Mezzanine::XML::NamedNodeIterator const *");
22056  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::Print",2,"std::basic_ostream< wchar_t,std::char_traits< wchar_t > > &");
22057  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::Print",3,"Mezzanine::Char8 const *");
22058  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::XML::Node::Print",4,"unsigned int");
22059  if(!lua_isnumber(L,5)) SWIG_fail_arg("Mezzanine::XML::Node::Print",5,"unsigned int");
22060 
22061  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
22062  SWIG_fail_ptr("NamedNodeIterator_Print",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
22063  }
22064 
22065 
22066  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__basic_ostreamT_wchar_t_std__char_traitsT_wchar_t_t_t,0))){
22067  SWIG_fail_ptr("NamedNodeIterator_Print",2,SWIGTYPE_p_std__basic_ostreamT_wchar_t_std__char_traitsT_wchar_t_t_t);
22068  }
22069 
22070  arg3 = (Mezzanine::Char8 *)lua_tostring(L, 3);
22071  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
22072  arg4 = (unsigned int)lua_tonumber(L, 4);
22073  SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative")
22074  arg5 = (unsigned int)lua_tonumber(L, 5);
22075  (*arg1)->Print(*arg2,(Mezzanine::Char8 const *)arg3,arg4,arg5);
22076 
22077  return SWIG_arg;
22078 
22079  if(0) SWIG_fail;
22080 
22081 fail:
22082  lua_error(L);
22083  return SWIG_arg;
22084 }
22085 
22086 
22087 static int _wrap_NamedNodeIterator_Print__SWIG_11(lua_State* L) {
22088  int SWIG_arg = 0;
22090  std::basic_ostream< wchar_t,std::char_traits< wchar_t > > *arg2 = 0 ;
22091  Mezzanine::Char8 *arg3 = (Mezzanine::Char8 *) 0 ;
22092  unsigned int arg4 ;
22093 
22094  SWIG_check_num_args("Mezzanine::XML::Node::Print",4,4)
22095  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Print",1,"Mezzanine::XML::NamedNodeIterator const *");
22096  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::Print",2,"std::basic_ostream< wchar_t,std::char_traits< wchar_t > > &");
22097  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::Print",3,"Mezzanine::Char8 const *");
22098  if(!lua_isnumber(L,4)) SWIG_fail_arg("Mezzanine::XML::Node::Print",4,"unsigned int");
22099 
22100  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
22101  SWIG_fail_ptr("NamedNodeIterator_Print",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
22102  }
22103 
22104 
22105  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__basic_ostreamT_wchar_t_std__char_traitsT_wchar_t_t_t,0))){
22106  SWIG_fail_ptr("NamedNodeIterator_Print",2,SWIGTYPE_p_std__basic_ostreamT_wchar_t_std__char_traitsT_wchar_t_t_t);
22107  }
22108 
22109  arg3 = (Mezzanine::Char8 *)lua_tostring(L, 3);
22110  SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative")
22111  arg4 = (unsigned int)lua_tonumber(L, 4);
22112  (*arg1)->Print(*arg2,(Mezzanine::Char8 const *)arg3,arg4);
22113 
22114  return SWIG_arg;
22115 
22116  if(0) SWIG_fail;
22117 
22118 fail:
22119  lua_error(L);
22120  return SWIG_arg;
22121 }
22122 
22123 
22124 static int _wrap_NamedNodeIterator_Print__SWIG_12(lua_State* L) {
22125  int SWIG_arg = 0;
22127  std::basic_ostream< wchar_t,std::char_traits< wchar_t > > *arg2 = 0 ;
22128  Mezzanine::Char8 *arg3 = (Mezzanine::Char8 *) 0 ;
22129 
22130  SWIG_check_num_args("Mezzanine::XML::Node::Print",3,3)
22131  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Print",1,"Mezzanine::XML::NamedNodeIterator const *");
22132  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::Print",2,"std::basic_ostream< wchar_t,std::char_traits< wchar_t > > &");
22133  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("Mezzanine::XML::Node::Print",3,"Mezzanine::Char8 const *");
22134 
22135  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
22136  SWIG_fail_ptr("NamedNodeIterator_Print",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
22137  }
22138 
22139 
22140  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__basic_ostreamT_wchar_t_std__char_traitsT_wchar_t_t_t,0))){
22141  SWIG_fail_ptr("NamedNodeIterator_Print",2,SWIGTYPE_p_std__basic_ostreamT_wchar_t_std__char_traitsT_wchar_t_t_t);
22142  }
22143 
22144  arg3 = (Mezzanine::Char8 *)lua_tostring(L, 3);
22145  (*arg1)->Print(*arg2,(Mezzanine::Char8 const *)arg3);
22146 
22147  return SWIG_arg;
22148 
22149  if(0) SWIG_fail;
22150 
22151 fail:
22152  lua_error(L);
22153  return SWIG_arg;
22154 }
22155 
22156 
22157 static int _wrap_NamedNodeIterator_Print__SWIG_13(lua_State* L) {
22158  int SWIG_arg = 0;
22160  std::basic_ostream< wchar_t,std::char_traits< wchar_t > > *arg2 = 0 ;
22161 
22162  SWIG_check_num_args("Mezzanine::XML::Node::Print",2,2)
22163  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::Print",1,"Mezzanine::XML::NamedNodeIterator const *");
22164  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::Print",2,"std::basic_ostream< wchar_t,std::char_traits< wchar_t > > &");
22165 
22166  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
22167  SWIG_fail_ptr("NamedNodeIterator_Print",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
22168  }
22169 
22170 
22171  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__basic_ostreamT_wchar_t_std__char_traitsT_wchar_t_t_t,0))){
22172  SWIG_fail_ptr("NamedNodeIterator_Print",2,SWIGTYPE_p_std__basic_ostreamT_wchar_t_std__char_traitsT_wchar_t_t_t);
22173  }
22174 
22175  (*arg1)->Print(*arg2);
22176 
22177  return SWIG_arg;
22178 
22179  if(0) SWIG_fail;
22180 
22181 fail:
22182  lua_error(L);
22183  return SWIG_arg;
22184 }
22185 
22186 
22187 static int _wrap_NamedNodeIterator_Print(lua_State* L) {
22188  int argc;
22189  int argv[7]={
22190  1,2,3,4,5,6,7
22191  };
22192 
22193  argc = lua_gettop(L);
22194  if (argc == 2) {
22195  int _v;
22196  {
22197  void *ptr;
22198  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator, 0)) {
22199  _v = 0;
22200  } else {
22201  _v = 1;
22202  }
22203  }
22204  if (_v) {
22205  {
22206  void *ptr;
22207  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Writer, 0)) {
22208  _v = 0;
22209  } else {
22210  _v = 1;
22211  }
22212  }
22213  if (_v) {
22214  return _wrap_NamedNodeIterator_Print__SWIG_4(L);
22215  }
22216  }
22217  }
22218  if (argc == 2) {
22219  int _v;
22220  {
22221  void *ptr;
22222  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator, 0)) {
22223  _v = 0;
22224  } else {
22225  _v = 1;
22226  }
22227  }
22228  if (_v) {
22229  {
22230  void *ptr;
22231  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0)) {
22232  _v = 0;
22233  } else {
22234  _v = 1;
22235  }
22236  }
22237  if (_v) {
22238  return _wrap_NamedNodeIterator_Print__SWIG_9(L);
22239  }
22240  }
22241  }
22242  if (argc == 2) {
22243  int _v;
22244  {
22245  void *ptr;
22246  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator, 0)) {
22247  _v = 0;
22248  } else {
22249  _v = 1;
22250  }
22251  }
22252  if (_v) {
22253  {
22254  void *ptr;
22255  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__basic_ostreamT_wchar_t_std__char_traitsT_wchar_t_t_t, 0)) {
22256  _v = 0;
22257  } else {
22258  _v = 1;
22259  }
22260  }
22261  if (_v) {
22262  return _wrap_NamedNodeIterator_Print__SWIG_13(L);
22263  }
22264  }
22265  }
22266  if (argc == 3) {
22267  int _v;
22268  {
22269  void *ptr;
22270  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator, 0)) {
22271  _v = 0;
22272  } else {
22273  _v = 1;
22274  }
22275  }
22276  if (_v) {
22277  {
22278  void *ptr;
22279  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Writer, 0)) {
22280  _v = 0;
22281  } else {
22282  _v = 1;
22283  }
22284  }
22285  if (_v) {
22286  {
22287  _v = SWIG_lua_isnilstring(L,argv[2]);
22288  }
22289  if (_v) {
22290  return _wrap_NamedNodeIterator_Print__SWIG_3(L);
22291  }
22292  }
22293  }
22294  }
22295  if (argc == 3) {
22296  int _v;
22297  {
22298  void *ptr;
22299  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator, 0)) {
22300  _v = 0;
22301  } else {
22302  _v = 1;
22303  }
22304  }
22305  if (_v) {
22306  {
22307  void *ptr;
22308  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__basic_ostreamT_wchar_t_std__char_traitsT_wchar_t_t_t, 0)) {
22309  _v = 0;
22310  } else {
22311  _v = 1;
22312  }
22313  }
22314  if (_v) {
22315  {
22316  _v = SWIG_lua_isnilstring(L,argv[2]);
22317  }
22318  if (_v) {
22319  return _wrap_NamedNodeIterator_Print__SWIG_12(L);
22320  }
22321  }
22322  }
22323  }
22324  if (argc == 3) {
22325  int _v;
22326  {
22327  void *ptr;
22328  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator, 0)) {
22329  _v = 0;
22330  } else {
22331  _v = 1;
22332  }
22333  }
22334  if (_v) {
22335  {
22336  void *ptr;
22337  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0)) {
22338  _v = 0;
22339  } else {
22340  _v = 1;
22341  }
22342  }
22343  if (_v) {
22344  {
22345  _v = SWIG_lua_isnilstring(L,argv[2]);
22346  }
22347  if (_v) {
22348  return _wrap_NamedNodeIterator_Print__SWIG_8(L);
22349  }
22350  }
22351  }
22352  }
22353  if (argc == 4) {
22354  int _v;
22355  {
22356  void *ptr;
22357  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator, 0)) {
22358  _v = 0;
22359  } else {
22360  _v = 1;
22361  }
22362  }
22363  if (_v) {
22364  {
22365  void *ptr;
22366  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__basic_ostreamT_wchar_t_std__char_traitsT_wchar_t_t_t, 0)) {
22367  _v = 0;
22368  } else {
22369  _v = 1;
22370  }
22371  }
22372  if (_v) {
22373  {
22374  _v = SWIG_lua_isnilstring(L,argv[2]);
22375  }
22376  if (_v) {
22377  {
22378  _v = lua_isnumber(L,argv[3]);
22379  }
22380  if (_v) {
22381  return _wrap_NamedNodeIterator_Print__SWIG_11(L);
22382  }
22383  }
22384  }
22385  }
22386  }
22387  if (argc == 4) {
22388  int _v;
22389  {
22390  void *ptr;
22391  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator, 0)) {
22392  _v = 0;
22393  } else {
22394  _v = 1;
22395  }
22396  }
22397  if (_v) {
22398  {
22399  void *ptr;
22400  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Writer, 0)) {
22401  _v = 0;
22402  } else {
22403  _v = 1;
22404  }
22405  }
22406  if (_v) {
22407  {
22408  _v = SWIG_lua_isnilstring(L,argv[2]);
22409  }
22410  if (_v) {
22411  {
22412  _v = lua_isnumber(L,argv[3]);
22413  }
22414  if (_v) {
22415  return _wrap_NamedNodeIterator_Print__SWIG_2(L);
22416  }
22417  }
22418  }
22419  }
22420  }
22421  if (argc == 4) {
22422  int _v;
22423  {
22424  void *ptr;
22425  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator, 0)) {
22426  _v = 0;
22427  } else {
22428  _v = 1;
22429  }
22430  }
22431  if (_v) {
22432  {
22433  void *ptr;
22434  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0)) {
22435  _v = 0;
22436  } else {
22437  _v = 1;
22438  }
22439  }
22440  if (_v) {
22441  {
22442  _v = SWIG_lua_isnilstring(L,argv[2]);
22443  }
22444  if (_v) {
22445  {
22446  _v = lua_isnumber(L,argv[3]);
22447  }
22448  if (_v) {
22449  return _wrap_NamedNodeIterator_Print__SWIG_7(L);
22450  }
22451  }
22452  }
22453  }
22454  }
22455  if (argc == 5) {
22456  int _v;
22457  {
22458  void *ptr;
22459  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator, 0)) {
22460  _v = 0;
22461  } else {
22462  _v = 1;
22463  }
22464  }
22465  if (_v) {
22466  {
22467  void *ptr;
22468  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0)) {
22469  _v = 0;
22470  } else {
22471  _v = 1;
22472  }
22473  }
22474  if (_v) {
22475  {
22476  _v = SWIG_lua_isnilstring(L,argv[2]);
22477  }
22478  if (_v) {
22479  {
22480  _v = lua_isnumber(L,argv[3]);
22481  }
22482  if (_v) {
22483  {
22484  _v = lua_isnumber(L,argv[4]);
22485  }
22486  if (_v) {
22487  return _wrap_NamedNodeIterator_Print__SWIG_6(L);
22488  }
22489  }
22490  }
22491  }
22492  }
22493  }
22494  if (argc == 5) {
22495  int _v;
22496  {
22497  void *ptr;
22498  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator, 0)) {
22499  _v = 0;
22500  } else {
22501  _v = 1;
22502  }
22503  }
22504  if (_v) {
22505  {
22506  void *ptr;
22507  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Writer, 0)) {
22508  _v = 0;
22509  } else {
22510  _v = 1;
22511  }
22512  }
22513  if (_v) {
22514  {
22515  _v = SWIG_lua_isnilstring(L,argv[2]);
22516  }
22517  if (_v) {
22518  {
22519  _v = lua_isnumber(L,argv[3]);
22520  }
22521  if (_v) {
22522  {
22523  _v = lua_isnumber(L,argv[4]);
22524  }
22525  if (_v) {
22526  return _wrap_NamedNodeIterator_Print__SWIG_1(L);
22527  }
22528  }
22529  }
22530  }
22531  }
22532  }
22533  if (argc == 5) {
22534  int _v;
22535  {
22536  void *ptr;
22537  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator, 0)) {
22538  _v = 0;
22539  } else {
22540  _v = 1;
22541  }
22542  }
22543  if (_v) {
22544  {
22545  void *ptr;
22546  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__basic_ostreamT_wchar_t_std__char_traitsT_wchar_t_t_t, 0)) {
22547  _v = 0;
22548  } else {
22549  _v = 1;
22550  }
22551  }
22552  if (_v) {
22553  {
22554  _v = SWIG_lua_isnilstring(L,argv[2]);
22555  }
22556  if (_v) {
22557  {
22558  _v = lua_isnumber(L,argv[3]);
22559  }
22560  if (_v) {
22561  {
22562  _v = lua_isnumber(L,argv[4]);
22563  }
22564  if (_v) {
22565  return _wrap_NamedNodeIterator_Print__SWIG_10(L);
22566  }
22567  }
22568  }
22569  }
22570  }
22571  }
22572  if (argc == 6) {
22573  int _v;
22574  {
22575  void *ptr;
22576  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator, 0)) {
22577  _v = 0;
22578  } else {
22579  _v = 1;
22580  }
22581  }
22582  if (_v) {
22583  {
22584  void *ptr;
22585  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Writer, 0)) {
22586  _v = 0;
22587  } else {
22588  _v = 1;
22589  }
22590  }
22591  if (_v) {
22592  {
22593  _v = SWIG_lua_isnilstring(L,argv[2]);
22594  }
22595  if (_v) {
22596  {
22597  _v = lua_isnumber(L,argv[3]);
22598  }
22599  if (_v) {
22600  {
22601  _v = lua_isnumber(L,argv[4]);
22602  }
22603  if (_v) {
22604  {
22605  _v = lua_isnumber(L,argv[5]);
22606  }
22607  if (_v) {
22608  return _wrap_NamedNodeIterator_Print__SWIG_0(L);
22609  }
22610  }
22611  }
22612  }
22613  }
22614  }
22615  }
22616  if (argc == 6) {
22617  int _v;
22618  {
22619  void *ptr;
22620  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator, 0)) {
22621  _v = 0;
22622  } else {
22623  _v = 1;
22624  }
22625  }
22626  if (_v) {
22627  {
22628  void *ptr;
22629  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0)) {
22630  _v = 0;
22631  } else {
22632  _v = 1;
22633  }
22634  }
22635  if (_v) {
22636  {
22637  _v = SWIG_lua_isnilstring(L,argv[2]);
22638  }
22639  if (_v) {
22640  {
22641  _v = lua_isnumber(L,argv[3]);
22642  }
22643  if (_v) {
22644  {
22645  _v = lua_isnumber(L,argv[4]);
22646  }
22647  if (_v) {
22648  {
22649  _v = lua_isnumber(L,argv[5]);
22650  }
22651  if (_v) {
22652  return _wrap_NamedNodeIterator_Print__SWIG_5(L);
22653  }
22654  }
22655  }
22656  }
22657  }
22658  }
22659  }
22660 
22661  lua_pushstring(L,"Wrong arguments for overloaded function 'NamedNodeIterator_Print'\n"
22662  " Possible C/C++ prototypes are:\n"
22663  " Mezzanine::XML::Node::Print(Mezzanine::XML::Writer &,Mezzanine::Char8 const *,unsigned int,Mezzanine::XML::Encoding,unsigned int) const\n"
22664  " Mezzanine::XML::Node::Print(Mezzanine::XML::Writer &,Mezzanine::Char8 const *,unsigned int,Mezzanine::XML::Encoding) const\n"
22665  " Mezzanine::XML::Node::Print(Mezzanine::XML::Writer &,Mezzanine::Char8 const *,unsigned int) const\n"
22666  " Mezzanine::XML::Node::Print(Mezzanine::XML::Writer &,Mezzanine::Char8 const *) const\n"
22667  " Mezzanine::XML::Node::Print(Mezzanine::XML::Writer &) const\n"
22668  " Mezzanine::XML::Node::Print(std::basic_ostream< char,std::char_traits< char > > &,Mezzanine::Char8 const *,unsigned int,Mezzanine::XML::Encoding,unsigned int) const\n"
22669  " Mezzanine::XML::Node::Print(std::basic_ostream< char,std::char_traits< char > > &,Mezzanine::Char8 const *,unsigned int,Mezzanine::XML::Encoding) const\n"
22670  " Mezzanine::XML::Node::Print(std::basic_ostream< char,std::char_traits< char > > &,Mezzanine::Char8 const *,unsigned int) const\n"
22671  " Mezzanine::XML::Node::Print(std::basic_ostream< char,std::char_traits< char > > &,Mezzanine::Char8 const *) const\n"
22672  " Mezzanine::XML::Node::Print(std::basic_ostream< char,std::char_traits< char > > &) const\n"
22673  " Mezzanine::XML::Node::Print(std::basic_ostream< wchar_t,std::char_traits< wchar_t > > &,Mezzanine::Char8 const *,unsigned int,unsigned int) const\n"
22674  " Mezzanine::XML::Node::Print(std::basic_ostream< wchar_t,std::char_traits< wchar_t > > &,Mezzanine::Char8 const *,unsigned int) const\n"
22675  " Mezzanine::XML::Node::Print(std::basic_ostream< wchar_t,std::char_traits< wchar_t > > &,Mezzanine::Char8 const *) const\n"
22676  " Mezzanine::XML::Node::Print(std::basic_ostream< wchar_t,std::char_traits< wchar_t > > &) const\n");
22677  lua_error(L);return 0;
22678 }
22679 
22680 
22681 static int _wrap_NamedNodeIterator_begin(lua_State* L) {
22682  int SWIG_arg = 0;
22685 
22686  SWIG_check_num_args("Mezzanine::XML::Node::begin",1,1)
22687  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::begin",1,"Mezzanine::XML::NamedNodeIterator const *");
22688 
22689  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
22690  SWIG_fail_ptr("NamedNodeIterator_begin",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
22691  }
22692 
22693  result = (*arg1)->begin();
22694  {
22696  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__NodeIterator,1); SWIG_arg++;
22697  }
22698  return SWIG_arg;
22699 
22700  if(0) SWIG_fail;
22701 
22702 fail:
22703  lua_error(L);
22704  return SWIG_arg;
22705 }
22706 
22707 
22708 static int _wrap_NamedNodeIterator_end(lua_State* L) {
22709  int SWIG_arg = 0;
22712 
22713  SWIG_check_num_args("Mezzanine::XML::Node::end",1,1)
22714  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::end",1,"Mezzanine::XML::NamedNodeIterator const *");
22715 
22716  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
22717  SWIG_fail_ptr("NamedNodeIterator_end",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
22718  }
22719 
22720  result = (*arg1)->end();
22721  {
22723  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__NodeIterator,1); SWIG_arg++;
22724  }
22725  return SWIG_arg;
22726 
22727  if(0) SWIG_fail;
22728 
22729 fail:
22730  lua_error(L);
22731  return SWIG_arg;
22732 }
22733 
22734 
22735 static int _wrap_NamedNodeIterator_attributes_begin(lua_State* L) {
22736  int SWIG_arg = 0;
22739 
22740  SWIG_check_num_args("Mezzanine::XML::Node::attributes_begin",1,1)
22741  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::attributes_begin",1,"Mezzanine::XML::NamedNodeIterator const *");
22742 
22743  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
22744  SWIG_fail_ptr("NamedNodeIterator_attributes_begin",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
22745  }
22746 
22747  result = (*arg1)->attributes_begin();
22748  {
22750  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__AttributeIterator,1); SWIG_arg++;
22751  }
22752  return SWIG_arg;
22753 
22754  if(0) SWIG_fail;
22755 
22756 fail:
22757  lua_error(L);
22758  return SWIG_arg;
22759 }
22760 
22761 
22762 static int _wrap_NamedNodeIterator_attributes_end(lua_State* L) {
22763  int SWIG_arg = 0;
22766 
22767  SWIG_check_num_args("Mezzanine::XML::Node::attributes_end",1,1)
22768  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::attributes_end",1,"Mezzanine::XML::NamedNodeIterator const *");
22769 
22770  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
22771  SWIG_fail_ptr("NamedNodeIterator_attributes_end",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
22772  }
22773 
22774  result = (*arg1)->attributes_end();
22775  {
22777  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__AttributeIterator,1); SWIG_arg++;
22778  }
22779  return SWIG_arg;
22780 
22781  if(0) SWIG_fail;
22782 
22783 fail:
22784  lua_error(L);
22785  return SWIG_arg;
22786 }
22787 
22788 
22789 static int _wrap_NamedNodeIterator_GetChildren__SWIG_0(lua_State* L) {
22790  int SWIG_arg = 0;
22792  SwigValueWrapper< Mezzanine::XML::ObjectRange< Mezzanine::XML::NodeIterator > > result;
22793 
22794  SWIG_check_num_args("Mezzanine::XML::Node::GetChildren",1,1)
22795  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::GetChildren",1,"Mezzanine::XML::NamedNodeIterator const *");
22796 
22797  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
22798  SWIG_fail_ptr("NamedNodeIterator_GetChildren",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
22799  }
22800 
22801  result = (*arg1)->GetChildren();
22802  {
22804  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__ObjectRangeT_Mezzanine__XML__NodeIterator_t,1); SWIG_arg++;
22805  }
22806  return SWIG_arg;
22807 
22808  if(0) SWIG_fail;
22809 
22810 fail:
22811  lua_error(L);
22812  return SWIG_arg;
22813 }
22814 
22815 
22816 static int _wrap_NamedNodeIterator_GetChildren__SWIG_1(lua_State* L) {
22817  int SWIG_arg = 0;
22819  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
22820  SwigValueWrapper< Mezzanine::XML::ObjectRange< Mezzanine::XML::NamedNodeIterator > > result;
22821 
22822  SWIG_check_num_args("Mezzanine::XML::Node::GetChildren",2,2)
22823  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::GetChildren",1,"Mezzanine::XML::NamedNodeIterator const *");
22824  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::Node::GetChildren",2,"Mezzanine::Char8 const *");
22825 
22826  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
22827  SWIG_fail_ptr("NamedNodeIterator_GetChildren",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
22828  }
22829 
22830  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
22831  result = (*arg1)->GetChildren((Mezzanine::Char8 const *)arg2);
22832  {
22834  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__ObjectRangeT_Mezzanine__XML__NamedNodeIterator_t,1); SWIG_arg++;
22835  }
22836  return SWIG_arg;
22837 
22838  if(0) SWIG_fail;
22839 
22840 fail:
22841  lua_error(L);
22842  return SWIG_arg;
22843 }
22844 
22845 
22846 static int _wrap_NamedNodeIterator_GetChildren(lua_State* L) {
22847  int argc;
22848  int argv[3]={
22849  1,2,3
22850  };
22851 
22852  argc = lua_gettop(L);
22853  if (argc == 1) {
22854  int _v;
22855  {
22856  void *ptr;
22857  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator, 0)) {
22858  _v = 0;
22859  } else {
22860  _v = 1;
22861  }
22862  }
22863  if (_v) {
22864  return _wrap_NamedNodeIterator_GetChildren__SWIG_0(L);
22865  }
22866  }
22867  if (argc == 2) {
22868  int _v;
22869  {
22870  void *ptr;
22871  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator, 0)) {
22872  _v = 0;
22873  } else {
22874  _v = 1;
22875  }
22876  }
22877  if (_v) {
22878  {
22879  _v = SWIG_lua_isnilstring(L,argv[1]);
22880  }
22881  if (_v) {
22882  return _wrap_NamedNodeIterator_GetChildren__SWIG_1(L);
22883  }
22884  }
22885  }
22886 
22887  lua_pushstring(L,"Wrong arguments for overloaded function 'NamedNodeIterator_GetChildren'\n"
22888  " Possible C/C++ prototypes are:\n"
22889  " Mezzanine::XML::Node::GetChildren() const\n"
22890  " Mezzanine::XML::Node::GetChildren(Mezzanine::Char8 const *) const\n");
22891  lua_error(L);return 0;
22892 }
22893 
22894 
22895 static int _wrap_NamedNodeIterator_attributes(lua_State* L) {
22896  int SWIG_arg = 0;
22898  SwigValueWrapper< Mezzanine::XML::ObjectRange< Mezzanine::XML::AttributeIterator > > result;
22899 
22900  SWIG_check_num_args("Mezzanine::XML::Node::attributes",1,1)
22901  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::attributes",1,"Mezzanine::XML::NamedNodeIterator const *");
22902 
22903  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
22904  SWIG_fail_ptr("NamedNodeIterator_attributes",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
22905  }
22906 
22907  result = (*arg1)->attributes();
22908  {
22910  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__ObjectRangeT_Mezzanine__XML__AttributeIterator_t,1); SWIG_arg++;
22911  }
22912  return SWIG_arg;
22913 
22914  if(0) SWIG_fail;
22915 
22916 fail:
22917  lua_error(L);
22918  return SWIG_arg;
22919 }
22920 
22921 
22922 static int _wrap_NamedNodeIterator_OffSetDebug(lua_State* L) {
22923  int SWIG_arg = 0;
22925  ptrdiff_t result;
22926 
22927  SWIG_check_num_args("Mezzanine::XML::Node::OffSetDebug",1,1)
22928  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::OffSetDebug",1,"Mezzanine::XML::NamedNodeIterator const *");
22929 
22930  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
22931  SWIG_fail_ptr("NamedNodeIterator_OffSetDebug",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
22932  }
22933 
22934  result = (*arg1)->OffSetDebug();
22935  {
22936  ptrdiff_t * resultptr = new ptrdiff_t((const ptrdiff_t &) result);
22937  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ptrdiff_t,1); SWIG_arg++;
22938  }
22939  return SWIG_arg;
22940 
22941  if(0) SWIG_fail;
22942 
22943 fail:
22944  lua_error(L);
22945  return SWIG_arg;
22946 }
22947 
22948 
22949 static int _wrap_NamedNodeIterator_HashValue(lua_State* L) {
22950  int SWIG_arg = 0;
22952  size_t result;
22953 
22954  SWIG_check_num_args("Mezzanine::XML::Node::HashValue",1,1)
22955  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::HashValue",1,"Mezzanine::XML::NamedNodeIterator const *");
22956 
22957  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
22958  SWIG_fail_ptr("NamedNodeIterator_HashValue",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
22959  }
22960 
22961  result = (*arg1)->HashValue();
22962  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
22963  return SWIG_arg;
22964 
22965  if(0) SWIG_fail;
22966 
22967 fail:
22968  lua_error(L);
22969  return SWIG_arg;
22970 }
22971 
22972 
22973 static int _wrap_NamedNodeIterator_InternalObject(lua_State* L) {
22974  int SWIG_arg = 0;
22976  Mezzanine::XML::NodeStruct *result = 0 ;
22977 
22978  SWIG_check_num_args("Mezzanine::XML::Node::InternalObject",1,1)
22979  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::Node::InternalObject",1,"Mezzanine::XML::NamedNodeIterator const *");
22980 
22981  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,0))){
22982  SWIG_fail_ptr("NamedNodeIterator_InternalObject",1,SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator);
22983  }
22984 
22985  result = (Mezzanine::XML::NodeStruct *)(*arg1)->InternalObject();
22986  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__XML__NodeStruct,0); SWIG_arg++;
22987  return SWIG_arg;
22988 
22989  if(0) SWIG_fail;
22990 
22991 fail:
22992  lua_error(L);
22993  return SWIG_arg;
22994 }
22995 
22996 
22997 static void swig_delete_NamedNodeIterator(void *obj) {
22999 delete arg1;
23000 }
23001 static swig_lua_method swig_Mezzanine_XML_NamedNodeIterator_methods[] = {
23002  {"__eq", _wrap_NamedNodeIterator___eq},
23003  {"__ref__", _wrap_NamedNodeIterator___ref__},
23004  {"__deref__", _wrap_NamedNodeIterator___deref__},
23005  {"__lt", _wrap_NamedNodeIterator___lt},
23006  {"__le", _wrap_NamedNodeIterator___le},
23007  {"Empty", _wrap_NamedNodeIterator_Empty},
23008  {"Type", _wrap_NamedNodeIterator_Type},
23009  {"Name", _wrap_NamedNodeIterator_Name},
23010  {"Value", _wrap_NamedNodeIterator_Value},
23011  {"GetFirstAttribute", _wrap_NamedNodeIterator_GetFirstAttribute},
23012  {"GetLastAttribute", _wrap_NamedNodeIterator_GetLastAttribute},
23013  {"GetFirstChild", _wrap_NamedNodeIterator_GetFirstChild},
23014  {"GetLastChild", _wrap_NamedNodeIterator_GetLastChild},
23015  {"GetNextSibling", _wrap_NamedNodeIterator_GetNextSibling},
23016  {"GetPreviousSibling", _wrap_NamedNodeIterator_GetPreviousSibling},
23017  {"GetParent", _wrap_NamedNodeIterator_GetParent},
23018  {"GetRoot", _wrap_NamedNodeIterator_GetRoot},
23019  {"GetText", _wrap_NamedNodeIterator_GetText},
23020  {"GetChild", _wrap_NamedNodeIterator_GetChild},
23021  {"GetAttribute", _wrap_NamedNodeIterator_GetAttribute},
23022  {"GetChildValue", _wrap_NamedNodeIterator_GetChildValue},
23023  {"SetName", _wrap_NamedNodeIterator_SetName},
23024  {"SetValue", _wrap_NamedNodeIterator_SetValue},
23025  {"AppendAttribute", _wrap_NamedNodeIterator_AppendAttribute},
23026  {"PrependAttribute", _wrap_NamedNodeIterator_PrependAttribute},
23027  {"InsertAttributeAfter", _wrap_NamedNodeIterator_InsertAttributeAfter},
23028  {"InsertAttributeBefore", _wrap_NamedNodeIterator_InsertAttributeBefore},
23029  {"AppendCopy", _wrap_NamedNodeIterator_AppendCopy},
23030  {"PrependCopy", _wrap_NamedNodeIterator_PrependCopy},
23031  {"InsertCopyAfter", _wrap_NamedNodeIterator_InsertCopyAfter},
23032  {"InsertCopyBefore", _wrap_NamedNodeIterator_InsertCopyBefore},
23033  {"AppendChild", _wrap_NamedNodeIterator_AppendChild},
23034  {"PrependChild", _wrap_NamedNodeIterator_PrependChild},
23035  {"InsertChildAfter", _wrap_NamedNodeIterator_InsertChildAfter},
23036  {"InsertChildBefore", _wrap_NamedNodeIterator_InsertChildBefore},
23037  {"RemoveAttribute", _wrap_NamedNodeIterator_RemoveAttribute},
23038  {"RemoveChild", _wrap_NamedNodeIterator_RemoveChild},
23039  {"FindChildbyAttribute", _wrap_NamedNodeIterator_FindChildbyAttribute},
23040  {"Path", _wrap_NamedNodeIterator_Path},
23041  {"FirstElementByPath", _wrap_NamedNodeIterator_FirstElementByPath},
23042  {"Traverse", _wrap_NamedNodeIterator_Traverse},
23043  {"FindSingleNode", _wrap_NamedNodeIterator_FindSingleNode},
23044  {"FindNodes", _wrap_NamedNodeIterator_FindNodes},
23045  {"Print", _wrap_NamedNodeIterator_Print},
23046  {"begin", _wrap_NamedNodeIterator_begin},
23047  {"end", _wrap_NamedNodeIterator_end},
23048  {"attributes_begin", _wrap_NamedNodeIterator_attributes_begin},
23049  {"attributes_end", _wrap_NamedNodeIterator_attributes_end},
23050  {"GetChildren", _wrap_NamedNodeIterator_GetChildren},
23051  {"attributes", _wrap_NamedNodeIterator_attributes},
23052  {"OffSetDebug", _wrap_NamedNodeIterator_OffSetDebug},
23053  {"HashValue", _wrap_NamedNodeIterator_HashValue},
23054  {"InternalObject", _wrap_NamedNodeIterator_InternalObject},
23055  {0,0}
23056 };
23057 static swig_lua_attribute swig_Mezzanine_XML_NamedNodeIterator_attributes[] = {
23058  {0,0,0}
23059 };
23060 static swig_lua_class *swig_Mezzanine_XML_NamedNodeIterator_bases[] = {0};
23061 static const char *swig_Mezzanine_XML_NamedNodeIterator_base_names[] = {0};
23062 static swig_lua_class _wrap_class_Mezzanine_XML_NamedNodeIterator = { "NamedNodeIterator", &SWIGTYPE_p_Mezzanine__XML__NamedNodeIterator,_wrap_new_NamedNodeIterator, swig_delete_NamedNodeIterator, swig_Mezzanine_XML_NamedNodeIterator_methods, swig_Mezzanine_XML_NamedNodeIterator_attributes, swig_Mezzanine_XML_NamedNodeIterator_bases, swig_Mezzanine_XML_NamedNodeIterator_base_names };
23063 
23064 static int _wrap_new_NodeText(lua_State* L) {
23065  int SWIG_arg = 0;
23066  Mezzanine::XML::NodeText *result = 0 ;
23067 
23068  SWIG_check_num_args("Mezzanine::XML::NodeText::NodeText",0,0)
23069  result = (Mezzanine::XML::NodeText *)new Mezzanine::XML::NodeText();
23070  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__XML__NodeText,1); SWIG_arg++;
23071  return SWIG_arg;
23072 
23073  if(0) SWIG_fail;
23074 
23075 fail:
23076  lua_error(L);
23077  return SWIG_arg;
23078 }
23079 
23080 
23081 static int _wrap_NodeText_Empty(lua_State* L) {
23082  int SWIG_arg = 0;
23084  bool result;
23085 
23086  SWIG_check_num_args("Mezzanine::XML::NodeText::Empty",1,1)
23087  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::NodeText::Empty",1,"Mezzanine::XML::NodeText const *");
23088 
23089  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeText,0))){
23090  SWIG_fail_ptr("NodeText_Empty",1,SWIGTYPE_p_Mezzanine__XML__NodeText);
23091  }
23092 
23093  result = (bool)((Mezzanine::XML::NodeText const *)arg1)->Empty();
23094  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
23095  return SWIG_arg;
23096 
23097  if(0) SWIG_fail;
23098 
23099 fail:
23100  lua_error(L);
23101  return SWIG_arg;
23102 }
23103 
23104 
23105 static int _wrap_NodeText_GetString(lua_State* L) {
23106  int SWIG_arg = 0;
23108  Mezzanine::Char8 *result = 0 ;
23109 
23110  SWIG_check_num_args("Mezzanine::XML::NodeText::GetString",1,1)
23111  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::NodeText::GetString",1,"Mezzanine::XML::NodeText const *");
23112 
23113  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeText,0))){
23114  SWIG_fail_ptr("NodeText_GetString",1,SWIGTYPE_p_Mezzanine__XML__NodeText);
23115  }
23116 
23117  result = (Mezzanine::Char8 *)((Mezzanine::XML::NodeText const *)arg1)->GetString();
23118  lua_pushstring(L,(const char *)result); SWIG_arg++;
23119  return SWIG_arg;
23120 
23121  if(0) SWIG_fail;
23122 
23123 fail:
23124  lua_error(L);
23125  return SWIG_arg;
23126 }
23127 
23128 
23129 static int _wrap_NodeText_AsString__SWIG_0(lua_State* L) {
23130  int SWIG_arg = 0;
23132  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
23133  Mezzanine::Char8 *result = 0 ;
23134 
23135  SWIG_check_num_args("Mezzanine::XML::NodeText::AsString",2,2)
23136  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::NodeText::AsString",1,"Mezzanine::XML::NodeText const *");
23137  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::NodeText::AsString",2,"Mezzanine::Char8 const *");
23138 
23139  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeText,0))){
23140  SWIG_fail_ptr("NodeText_AsString",1,SWIGTYPE_p_Mezzanine__XML__NodeText);
23141  }
23142 
23143  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
23144  result = (Mezzanine::Char8 *)((Mezzanine::XML::NodeText const *)arg1)->AsString((Mezzanine::Char8 const *)arg2);
23145  lua_pushstring(L,(const char *)result); SWIG_arg++;
23146  return SWIG_arg;
23147 
23148  if(0) SWIG_fail;
23149 
23150 fail:
23151  lua_error(L);
23152  return SWIG_arg;
23153 }
23154 
23155 
23156 static int _wrap_NodeText_AsString__SWIG_1(lua_State* L) {
23157  int SWIG_arg = 0;
23159  Mezzanine::Char8 *result = 0 ;
23160 
23161  SWIG_check_num_args("Mezzanine::XML::NodeText::AsString",1,1)
23162  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::NodeText::AsString",1,"Mezzanine::XML::NodeText const *");
23163 
23164  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeText,0))){
23165  SWIG_fail_ptr("NodeText_AsString",1,SWIGTYPE_p_Mezzanine__XML__NodeText);
23166  }
23167 
23168  result = (Mezzanine::Char8 *)((Mezzanine::XML::NodeText const *)arg1)->AsString();
23169  lua_pushstring(L,(const char *)result); SWIG_arg++;
23170  return SWIG_arg;
23171 
23172  if(0) SWIG_fail;
23173 
23174 fail:
23175  lua_error(L);
23176  return SWIG_arg;
23177 }
23178 
23179 
23180 static int _wrap_NodeText_AsString(lua_State* L) {
23181  int argc;
23182  int argv[3]={
23183  1,2,3
23184  };
23185 
23186  argc = lua_gettop(L);
23187  if (argc == 1) {
23188  int _v;
23189  {
23190  void *ptr;
23191  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeText, 0)) {
23192  _v = 0;
23193  } else {
23194  _v = 1;
23195  }
23196  }
23197  if (_v) {
23198  return _wrap_NodeText_AsString__SWIG_1(L);
23199  }
23200  }
23201  if (argc == 2) {
23202  int _v;
23203  {
23204  void *ptr;
23205  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeText, 0)) {
23206  _v = 0;
23207  } else {
23208  _v = 1;
23209  }
23210  }
23211  if (_v) {
23212  {
23213  _v = SWIG_lua_isnilstring(L,argv[1]);
23214  }
23215  if (_v) {
23216  return _wrap_NodeText_AsString__SWIG_0(L);
23217  }
23218  }
23219  }
23220 
23221  lua_pushstring(L,"Wrong arguments for overloaded function 'NodeText_AsString'\n"
23222  " Possible C/C++ prototypes are:\n"
23223  " Mezzanine::XML::NodeText::AsString(Mezzanine::Char8 const *) const\n"
23224  " Mezzanine::XML::NodeText::AsString() const\n");
23225  lua_error(L);return 0;
23226 }
23227 
23228 
23229 static int _wrap_NodeText_AsInt__SWIG_0(lua_State* L) {
23230  int SWIG_arg = 0;
23232  int arg2 ;
23233  int result;
23234 
23235  SWIG_check_num_args("Mezzanine::XML::NodeText::AsInt",2,2)
23236  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::NodeText::AsInt",1,"Mezzanine::XML::NodeText const *");
23237  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::XML::NodeText::AsInt",2,"int");
23238 
23239  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeText,0))){
23240  SWIG_fail_ptr("NodeText_AsInt",1,SWIGTYPE_p_Mezzanine__XML__NodeText);
23241  }
23242 
23243  arg2 = (int)lua_tonumber(L, 2);
23244  result = (int)((Mezzanine::XML::NodeText const *)arg1)->AsInt(arg2);
23245  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
23246  return SWIG_arg;
23247 
23248  if(0) SWIG_fail;
23249 
23250 fail:
23251  lua_error(L);
23252  return SWIG_arg;
23253 }
23254 
23255 
23256 static int _wrap_NodeText_AsInt__SWIG_1(lua_State* L) {
23257  int SWIG_arg = 0;
23259  int result;
23260 
23261  SWIG_check_num_args("Mezzanine::XML::NodeText::AsInt",1,1)
23262  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::NodeText::AsInt",1,"Mezzanine::XML::NodeText const *");
23263 
23264  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeText,0))){
23265  SWIG_fail_ptr("NodeText_AsInt",1,SWIGTYPE_p_Mezzanine__XML__NodeText);
23266  }
23267 
23268  result = (int)((Mezzanine::XML::NodeText const *)arg1)->AsInt();
23269  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
23270  return SWIG_arg;
23271 
23272  if(0) SWIG_fail;
23273 
23274 fail:
23275  lua_error(L);
23276  return SWIG_arg;
23277 }
23278 
23279 
23280 static int _wrap_NodeText_AsInt(lua_State* L) {
23281  int argc;
23282  int argv[3]={
23283  1,2,3
23284  };
23285 
23286  argc = lua_gettop(L);
23287  if (argc == 1) {
23288  int _v;
23289  {
23290  void *ptr;
23291  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeText, 0)) {
23292  _v = 0;
23293  } else {
23294  _v = 1;
23295  }
23296  }
23297  if (_v) {
23298  return _wrap_NodeText_AsInt__SWIG_1(L);
23299  }
23300  }
23301  if (argc == 2) {
23302  int _v;
23303  {
23304  void *ptr;
23305  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeText, 0)) {
23306  _v = 0;
23307  } else {
23308  _v = 1;
23309  }
23310  }
23311  if (_v) {
23312  {
23313  _v = lua_isnumber(L,argv[1]);
23314  }
23315  if (_v) {
23316  return _wrap_NodeText_AsInt__SWIG_0(L);
23317  }
23318  }
23319  }
23320 
23321  lua_pushstring(L,"Wrong arguments for overloaded function 'NodeText_AsInt'\n"
23322  " Possible C/C++ prototypes are:\n"
23323  " Mezzanine::XML::NodeText::AsInt(int) const\n"
23324  " Mezzanine::XML::NodeText::AsInt() const\n");
23325  lua_error(L);return 0;
23326 }
23327 
23328 
23329 static int _wrap_NodeText_AsUint__SWIG_0(lua_State* L) {
23330  int SWIG_arg = 0;
23332  unsigned int arg2 ;
23333  unsigned int result;
23334 
23335  SWIG_check_num_args("Mezzanine::XML::NodeText::AsUint",2,2)
23336  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::NodeText::AsUint",1,"Mezzanine::XML::NodeText const *");
23337  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::XML::NodeText::AsUint",2,"unsigned int");
23338 
23339  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeText,0))){
23340  SWIG_fail_ptr("NodeText_AsUint",1,SWIGTYPE_p_Mezzanine__XML__NodeText);
23341  }
23342 
23343  SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative")
23344  arg2 = (unsigned int)lua_tonumber(L, 2);
23345  result = (unsigned int)((Mezzanine::XML::NodeText const *)arg1)->AsUint(arg2);
23346  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
23347  return SWIG_arg;
23348 
23349  if(0) SWIG_fail;
23350 
23351 fail:
23352  lua_error(L);
23353  return SWIG_arg;
23354 }
23355 
23356 
23357 static int _wrap_NodeText_AsUint__SWIG_1(lua_State* L) {
23358  int SWIG_arg = 0;
23360  unsigned int result;
23361 
23362  SWIG_check_num_args("Mezzanine::XML::NodeText::AsUint",1,1)
23363  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::NodeText::AsUint",1,"Mezzanine::XML::NodeText const *");
23364 
23365  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeText,0))){
23366  SWIG_fail_ptr("NodeText_AsUint",1,SWIGTYPE_p_Mezzanine__XML__NodeText);
23367  }
23368 
23369  result = (unsigned int)((Mezzanine::XML::NodeText const *)arg1)->AsUint();
23370  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
23371  return SWIG_arg;
23372 
23373  if(0) SWIG_fail;
23374 
23375 fail:
23376  lua_error(L);
23377  return SWIG_arg;
23378 }
23379 
23380 
23381 static int _wrap_NodeText_AsUint(lua_State* L) {
23382  int argc;
23383  int argv[3]={
23384  1,2,3
23385  };
23386 
23387  argc = lua_gettop(L);
23388  if (argc == 1) {
23389  int _v;
23390  {
23391  void *ptr;
23392  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeText, 0)) {
23393  _v = 0;
23394  } else {
23395  _v = 1;
23396  }
23397  }
23398  if (_v) {
23399  return _wrap_NodeText_AsUint__SWIG_1(L);
23400  }
23401  }
23402  if (argc == 2) {
23403  int _v;
23404  {
23405  void *ptr;
23406  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeText, 0)) {
23407  _v = 0;
23408  } else {
23409  _v = 1;
23410  }
23411  }
23412  if (_v) {
23413  {
23414  _v = lua_isnumber(L,argv[1]);
23415  }
23416  if (_v) {
23417  return _wrap_NodeText_AsUint__SWIG_0(L);
23418  }
23419  }
23420  }
23421 
23422  lua_pushstring(L,"Wrong arguments for overloaded function 'NodeText_AsUint'\n"
23423  " Possible C/C++ prototypes are:\n"
23424  " Mezzanine::XML::NodeText::AsUint(unsigned int) const\n"
23425  " Mezzanine::XML::NodeText::AsUint() const\n");
23426  lua_error(L);return 0;
23427 }
23428 
23429 
23430 static int _wrap_NodeText_AsDouble__SWIG_0(lua_State* L) {
23431  int SWIG_arg = 0;
23433  double arg2 ;
23434  double result;
23435 
23436  SWIG_check_num_args("Mezzanine::XML::NodeText::AsDouble",2,2)
23437  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::NodeText::AsDouble",1,"Mezzanine::XML::NodeText const *");
23438  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::XML::NodeText::AsDouble",2,"double");
23439 
23440  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeText,0))){
23441  SWIG_fail_ptr("NodeText_AsDouble",1,SWIGTYPE_p_Mezzanine__XML__NodeText);
23442  }
23443 
23444  arg2 = (double)lua_tonumber(L, 2);
23445  result = (double)((Mezzanine::XML::NodeText const *)arg1)->AsDouble(arg2);
23446  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
23447  return SWIG_arg;
23448 
23449  if(0) SWIG_fail;
23450 
23451 fail:
23452  lua_error(L);
23453  return SWIG_arg;
23454 }
23455 
23456 
23457 static int _wrap_NodeText_AsDouble__SWIG_1(lua_State* L) {
23458  int SWIG_arg = 0;
23460  double result;
23461 
23462  SWIG_check_num_args("Mezzanine::XML::NodeText::AsDouble",1,1)
23463  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::NodeText::AsDouble",1,"Mezzanine::XML::NodeText const *");
23464 
23465  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeText,0))){
23466  SWIG_fail_ptr("NodeText_AsDouble",1,SWIGTYPE_p_Mezzanine__XML__NodeText);
23467  }
23468 
23469  result = (double)((Mezzanine::XML::NodeText const *)arg1)->AsDouble();
23470  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
23471  return SWIG_arg;
23472 
23473  if(0) SWIG_fail;
23474 
23475 fail:
23476  lua_error(L);
23477  return SWIG_arg;
23478 }
23479 
23480 
23481 static int _wrap_NodeText_AsDouble(lua_State* L) {
23482  int argc;
23483  int argv[3]={
23484  1,2,3
23485  };
23486 
23487  argc = lua_gettop(L);
23488  if (argc == 1) {
23489  int _v;
23490  {
23491  void *ptr;
23492  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeText, 0)) {
23493  _v = 0;
23494  } else {
23495  _v = 1;
23496  }
23497  }
23498  if (_v) {
23499  return _wrap_NodeText_AsDouble__SWIG_1(L);
23500  }
23501  }
23502  if (argc == 2) {
23503  int _v;
23504  {
23505  void *ptr;
23506  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeText, 0)) {
23507  _v = 0;
23508  } else {
23509  _v = 1;
23510  }
23511  }
23512  if (_v) {
23513  {
23514  _v = lua_isnumber(L,argv[1]);
23515  }
23516  if (_v) {
23517  return _wrap_NodeText_AsDouble__SWIG_0(L);
23518  }
23519  }
23520  }
23521 
23522  lua_pushstring(L,"Wrong arguments for overloaded function 'NodeText_AsDouble'\n"
23523  " Possible C/C++ prototypes are:\n"
23524  " Mezzanine::XML::NodeText::AsDouble(double) const\n"
23525  " Mezzanine::XML::NodeText::AsDouble() const\n");
23526  lua_error(L);return 0;
23527 }
23528 
23529 
23530 static int _wrap_NodeText_AsFloat__SWIG_0(lua_State* L) {
23531  int SWIG_arg = 0;
23533  float arg2 ;
23534  float result;
23535 
23536  SWIG_check_num_args("Mezzanine::XML::NodeText::AsFloat",2,2)
23537  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::NodeText::AsFloat",1,"Mezzanine::XML::NodeText const *");
23538  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::XML::NodeText::AsFloat",2,"float");
23539 
23540  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeText,0))){
23541  SWIG_fail_ptr("NodeText_AsFloat",1,SWIGTYPE_p_Mezzanine__XML__NodeText);
23542  }
23543 
23544  arg2 = (float)lua_tonumber(L, 2);
23545  result = (float)((Mezzanine::XML::NodeText const *)arg1)->AsFloat(arg2);
23546  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
23547  return SWIG_arg;
23548 
23549  if(0) SWIG_fail;
23550 
23551 fail:
23552  lua_error(L);
23553  return SWIG_arg;
23554 }
23555 
23556 
23557 static int _wrap_NodeText_AsFloat__SWIG_1(lua_State* L) {
23558  int SWIG_arg = 0;
23560  float result;
23561 
23562  SWIG_check_num_args("Mezzanine::XML::NodeText::AsFloat",1,1)
23563  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::NodeText::AsFloat",1,"Mezzanine::XML::NodeText const *");
23564 
23565  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeText,0))){
23566  SWIG_fail_ptr("NodeText_AsFloat",1,SWIGTYPE_p_Mezzanine__XML__NodeText);
23567  }
23568 
23569  result = (float)((Mezzanine::XML::NodeText const *)arg1)->AsFloat();
23570  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
23571  return SWIG_arg;
23572 
23573  if(0) SWIG_fail;
23574 
23575 fail:
23576  lua_error(L);
23577  return SWIG_arg;
23578 }
23579 
23580 
23581 static int _wrap_NodeText_AsFloat(lua_State* L) {
23582  int argc;
23583  int argv[3]={
23584  1,2,3
23585  };
23586 
23587  argc = lua_gettop(L);
23588  if (argc == 1) {
23589  int _v;
23590  {
23591  void *ptr;
23592  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeText, 0)) {
23593  _v = 0;
23594  } else {
23595  _v = 1;
23596  }
23597  }
23598  if (_v) {
23599  return _wrap_NodeText_AsFloat__SWIG_1(L);
23600  }
23601  }
23602  if (argc == 2) {
23603  int _v;
23604  {
23605  void *ptr;
23606  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeText, 0)) {
23607  _v = 0;
23608  } else {
23609  _v = 1;
23610  }
23611  }
23612  if (_v) {
23613  {
23614  _v = lua_isnumber(L,argv[1]);
23615  }
23616  if (_v) {
23617  return _wrap_NodeText_AsFloat__SWIG_0(L);
23618  }
23619  }
23620  }
23621 
23622  lua_pushstring(L,"Wrong arguments for overloaded function 'NodeText_AsFloat'\n"
23623  " Possible C/C++ prototypes are:\n"
23624  " Mezzanine::XML::NodeText::AsFloat(float) const\n"
23625  " Mezzanine::XML::NodeText::AsFloat() const\n");
23626  lua_error(L);return 0;
23627 }
23628 
23629 
23630 static int _wrap_NodeText_AsReal__SWIG_0(lua_State* L) {
23631  int SWIG_arg = 0;
23633  Mezzanine::Real arg2 ;
23634  Mezzanine::Real result;
23635 
23636  SWIG_check_num_args("Mezzanine::XML::NodeText::AsReal",2,2)
23637  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::NodeText::AsReal",1,"Mezzanine::XML::NodeText const *");
23638  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::XML::NodeText::AsReal",2,"Mezzanine::Real");
23639 
23640  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeText,0))){
23641  SWIG_fail_ptr("NodeText_AsReal",1,SWIGTYPE_p_Mezzanine__XML__NodeText);
23642  }
23643 
23644  arg2 = (Mezzanine::Real)lua_tonumber(L, 2);
23645  result = (Mezzanine::Real)((Mezzanine::XML::NodeText const *)arg1)->AsReal(arg2);
23646  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
23647  return SWIG_arg;
23648 
23649  if(0) SWIG_fail;
23650 
23651 fail:
23652  lua_error(L);
23653  return SWIG_arg;
23654 }
23655 
23656 
23657 static int _wrap_NodeText_AsReal__SWIG_1(lua_State* L) {
23658  int SWIG_arg = 0;
23660  Mezzanine::Real result;
23661 
23662  SWIG_check_num_args("Mezzanine::XML::NodeText::AsReal",1,1)
23663  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::NodeText::AsReal",1,"Mezzanine::XML::NodeText const *");
23664 
23665  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeText,0))){
23666  SWIG_fail_ptr("NodeText_AsReal",1,SWIGTYPE_p_Mezzanine__XML__NodeText);
23667  }
23668 
23669  result = (Mezzanine::Real)((Mezzanine::XML::NodeText const *)arg1)->AsReal();
23670  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
23671  return SWIG_arg;
23672 
23673  if(0) SWIG_fail;
23674 
23675 fail:
23676  lua_error(L);
23677  return SWIG_arg;
23678 }
23679 
23680 
23681 static int _wrap_NodeText_AsReal(lua_State* L) {
23682  int argc;
23683  int argv[3]={
23684  1,2,3
23685  };
23686 
23687  argc = lua_gettop(L);
23688  if (argc == 1) {
23689  int _v;
23690  {
23691  void *ptr;
23692  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeText, 0)) {
23693  _v = 0;
23694  } else {
23695  _v = 1;
23696  }
23697  }
23698  if (_v) {
23699  return _wrap_NodeText_AsReal__SWIG_1(L);
23700  }
23701  }
23702  if (argc == 2) {
23703  int _v;
23704  {
23705  void *ptr;
23706  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeText, 0)) {
23707  _v = 0;
23708  } else {
23709  _v = 1;
23710  }
23711  }
23712  if (_v) {
23713  {
23714  _v = lua_isnumber(L,argv[1]);
23715  }
23716  if (_v) {
23717  return _wrap_NodeText_AsReal__SWIG_0(L);
23718  }
23719  }
23720  }
23721 
23722  lua_pushstring(L,"Wrong arguments for overloaded function 'NodeText_AsReal'\n"
23723  " Possible C/C++ prototypes are:\n"
23724  " Mezzanine::XML::NodeText::AsReal(Mezzanine::Real) const\n"
23725  " Mezzanine::XML::NodeText::AsReal() const\n");
23726  lua_error(L);return 0;
23727 }
23728 
23729 
23730 static int _wrap_NodeText_AsWhole__SWIG_0(lua_State* L) {
23731  int SWIG_arg = 0;
23733  Mezzanine::Whole arg2 ;
23734  Mezzanine::Whole result;
23735 
23736  SWIG_check_num_args("Mezzanine::XML::NodeText::AsWhole",2,2)
23737  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::NodeText::AsWhole",1,"Mezzanine::XML::NodeText const *");
23738  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::XML::NodeText::AsWhole",2,"Mezzanine::Whole");
23739 
23740  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeText,0))){
23741  SWIG_fail_ptr("NodeText_AsWhole",1,SWIGTYPE_p_Mezzanine__XML__NodeText);
23742  }
23743 
23744  SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative")
23745  arg2 = (Mezzanine::Whole)lua_tonumber(L, 2);
23746  result = (Mezzanine::Whole)((Mezzanine::XML::NodeText const *)arg1)->AsWhole(arg2);
23747  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
23748  return SWIG_arg;
23749 
23750  if(0) SWIG_fail;
23751 
23752 fail:
23753  lua_error(L);
23754  return SWIG_arg;
23755 }
23756 
23757 
23758 static int _wrap_NodeText_AsWhole__SWIG_1(lua_State* L) {
23759  int SWIG_arg = 0;
23761  Mezzanine::Whole result;
23762 
23763  SWIG_check_num_args("Mezzanine::XML::NodeText::AsWhole",1,1)
23764  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::NodeText::AsWhole",1,"Mezzanine::XML::NodeText const *");
23765 
23766  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeText,0))){
23767  SWIG_fail_ptr("NodeText_AsWhole",1,SWIGTYPE_p_Mezzanine__XML__NodeText);
23768  }
23769 
23770  result = (Mezzanine::Whole)((Mezzanine::XML::NodeText const *)arg1)->AsWhole();
23771  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
23772  return SWIG_arg;
23773 
23774  if(0) SWIG_fail;
23775 
23776 fail:
23777  lua_error(L);
23778  return SWIG_arg;
23779 }
23780 
23781 
23782 static int _wrap_NodeText_AsWhole(lua_State* L) {
23783  int argc;
23784  int argv[3]={
23785  1,2,3
23786  };
23787 
23788  argc = lua_gettop(L);
23789  if (argc == 1) {
23790  int _v;
23791  {
23792  void *ptr;
23793  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeText, 0)) {
23794  _v = 0;
23795  } else {
23796  _v = 1;
23797  }
23798  }
23799  if (_v) {
23800  return _wrap_NodeText_AsWhole__SWIG_1(L);
23801  }
23802  }
23803  if (argc == 2) {
23804  int _v;
23805  {
23806  void *ptr;
23807  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeText, 0)) {
23808  _v = 0;
23809  } else {
23810  _v = 1;
23811  }
23812  }
23813  if (_v) {
23814  {
23815  _v = lua_isnumber(L,argv[1]);
23816  }
23817  if (_v) {
23818  return _wrap_NodeText_AsWhole__SWIG_0(L);
23819  }
23820  }
23821  }
23822 
23823  lua_pushstring(L,"Wrong arguments for overloaded function 'NodeText_AsWhole'\n"
23824  " Possible C/C++ prototypes are:\n"
23825  " Mezzanine::XML::NodeText::AsWhole(Mezzanine::Whole) const\n"
23826  " Mezzanine::XML::NodeText::AsWhole() const\n");
23827  lua_error(L);return 0;
23828 }
23829 
23830 
23831 static int _wrap_NodeText_AsInteger__SWIG_0(lua_State* L) {
23832  int SWIG_arg = 0;
23834  Mezzanine::Integer arg2 ;
23835  Mezzanine::Integer result;
23836 
23837  SWIG_check_num_args("Mezzanine::XML::NodeText::AsInteger",2,2)
23838  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::NodeText::AsInteger",1,"Mezzanine::XML::NodeText const *");
23839  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::XML::NodeText::AsInteger",2,"Mezzanine::Integer");
23840 
23841  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeText,0))){
23842  SWIG_fail_ptr("NodeText_AsInteger",1,SWIGTYPE_p_Mezzanine__XML__NodeText);
23843  }
23844 
23845  arg2 = (Mezzanine::Integer)lua_tonumber(L, 2);
23846  result = (Mezzanine::Integer)((Mezzanine::XML::NodeText const *)arg1)->AsInteger(arg2);
23847  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
23848  return SWIG_arg;
23849 
23850  if(0) SWIG_fail;
23851 
23852 fail:
23853  lua_error(L);
23854  return SWIG_arg;
23855 }
23856 
23857 
23858 static int _wrap_NodeText_AsInteger__SWIG_1(lua_State* L) {
23859  int SWIG_arg = 0;
23861  Mezzanine::Integer result;
23862 
23863  SWIG_check_num_args("Mezzanine::XML::NodeText::AsInteger",1,1)
23864  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::NodeText::AsInteger",1,"Mezzanine::XML::NodeText const *");
23865 
23866  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeText,0))){
23867  SWIG_fail_ptr("NodeText_AsInteger",1,SWIGTYPE_p_Mezzanine__XML__NodeText);
23868  }
23869 
23870  result = (Mezzanine::Integer)((Mezzanine::XML::NodeText const *)arg1)->AsInteger();
23871  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
23872  return SWIG_arg;
23873 
23874  if(0) SWIG_fail;
23875 
23876 fail:
23877  lua_error(L);
23878  return SWIG_arg;
23879 }
23880 
23881 
23882 static int _wrap_NodeText_AsInteger(lua_State* L) {
23883  int argc;
23884  int argv[3]={
23885  1,2,3
23886  };
23887 
23888  argc = lua_gettop(L);
23889  if (argc == 1) {
23890  int _v;
23891  {
23892  void *ptr;
23893  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeText, 0)) {
23894  _v = 0;
23895  } else {
23896  _v = 1;
23897  }
23898  }
23899  if (_v) {
23900  return _wrap_NodeText_AsInteger__SWIG_1(L);
23901  }
23902  }
23903  if (argc == 2) {
23904  int _v;
23905  {
23906  void *ptr;
23907  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeText, 0)) {
23908  _v = 0;
23909  } else {
23910  _v = 1;
23911  }
23912  }
23913  if (_v) {
23914  {
23915  _v = lua_isnumber(L,argv[1]);
23916  }
23917  if (_v) {
23918  return _wrap_NodeText_AsInteger__SWIG_0(L);
23919  }
23920  }
23921  }
23922 
23923  lua_pushstring(L,"Wrong arguments for overloaded function 'NodeText_AsInteger'\n"
23924  " Possible C/C++ prototypes are:\n"
23925  " Mezzanine::XML::NodeText::AsInteger(Mezzanine::Integer) const\n"
23926  " Mezzanine::XML::NodeText::AsInteger() const\n");
23927  lua_error(L);return 0;
23928 }
23929 
23930 
23931 static int _wrap_NodeText_AsBool__SWIG_0(lua_State* L) {
23932  int SWIG_arg = 0;
23934  bool arg2 ;
23935  bool result;
23936 
23937  SWIG_check_num_args("Mezzanine::XML::NodeText::AsBool",2,2)
23938  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::NodeText::AsBool",1,"Mezzanine::XML::NodeText const *");
23939  if(!lua_isboolean(L,2)) SWIG_fail_arg("Mezzanine::XML::NodeText::AsBool",2,"bool");
23940 
23941  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeText,0))){
23942  SWIG_fail_ptr("NodeText_AsBool",1,SWIGTYPE_p_Mezzanine__XML__NodeText);
23943  }
23944 
23945  arg2 = (lua_toboolean(L, 2)!=0);
23946  result = (bool)((Mezzanine::XML::NodeText const *)arg1)->AsBool(arg2);
23947  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
23948  return SWIG_arg;
23949 
23950  if(0) SWIG_fail;
23951 
23952 fail:
23953  lua_error(L);
23954  return SWIG_arg;
23955 }
23956 
23957 
23958 static int _wrap_NodeText_AsBool__SWIG_1(lua_State* L) {
23959  int SWIG_arg = 0;
23961  bool result;
23962 
23963  SWIG_check_num_args("Mezzanine::XML::NodeText::AsBool",1,1)
23964  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::NodeText::AsBool",1,"Mezzanine::XML::NodeText const *");
23965 
23966  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeText,0))){
23967  SWIG_fail_ptr("NodeText_AsBool",1,SWIGTYPE_p_Mezzanine__XML__NodeText);
23968  }
23969 
23970  result = (bool)((Mezzanine::XML::NodeText const *)arg1)->AsBool();
23971  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
23972  return SWIG_arg;
23973 
23974  if(0) SWIG_fail;
23975 
23976 fail:
23977  lua_error(L);
23978  return SWIG_arg;
23979 }
23980 
23981 
23982 static int _wrap_NodeText_AsBool(lua_State* L) {
23983  int argc;
23984  int argv[3]={
23985  1,2,3
23986  };
23987 
23988  argc = lua_gettop(L);
23989  if (argc == 1) {
23990  int _v;
23991  {
23992  void *ptr;
23993  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeText, 0)) {
23994  _v = 0;
23995  } else {
23996  _v = 1;
23997  }
23998  }
23999  if (_v) {
24000  return _wrap_NodeText_AsBool__SWIG_1(L);
24001  }
24002  }
24003  if (argc == 2) {
24004  int _v;
24005  {
24006  void *ptr;
24007  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__NodeText, 0)) {
24008  _v = 0;
24009  } else {
24010  _v = 1;
24011  }
24012  }
24013  if (_v) {
24014  {
24015  _v = lua_isboolean(L,argv[1]);
24016  }
24017  if (_v) {
24018  return _wrap_NodeText_AsBool__SWIG_0(L);
24019  }
24020  }
24021  }
24022 
24023  lua_pushstring(L,"Wrong arguments for overloaded function 'NodeText_AsBool'\n"
24024  " Possible C/C++ prototypes are:\n"
24025  " Mezzanine::XML::NodeText::AsBool(bool) const\n"
24026  " Mezzanine::XML::NodeText::AsBool() const\n");
24027  lua_error(L);return 0;
24028 }
24029 
24030 
24031 static int _wrap_NodeText_Set(lua_State* L) {
24032  int SWIG_arg = 0;
24034  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
24035  bool result;
24036 
24037  SWIG_check_num_args("Mezzanine::XML::NodeText::Set",2,2)
24038  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::NodeText::Set",1,"Mezzanine::XML::NodeText *");
24039  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::NodeText::Set",2,"Mezzanine::Char8 const *");
24040 
24041  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeText,0))){
24042  SWIG_fail_ptr("NodeText_Set",1,SWIGTYPE_p_Mezzanine__XML__NodeText);
24043  }
24044 
24045  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
24046  result = (bool)(arg1)->Set((Mezzanine::Char8 const *)arg2);
24047  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
24048  return SWIG_arg;
24049 
24050  if(0) SWIG_fail;
24051 
24052 fail:
24053  lua_error(L);
24054  return SWIG_arg;
24055 }
24056 
24057 
24058 static int _wrap_NodeText_data(lua_State* L) {
24059  int SWIG_arg = 0;
24061  Mezzanine::XML::Node result;
24062 
24063  SWIG_check_num_args("Mezzanine::XML::NodeText::data",1,1)
24064  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::NodeText::data",1,"Mezzanine::XML::NodeText const *");
24065 
24066  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__NodeText,0))){
24067  SWIG_fail_ptr("NodeText_data",1,SWIGTYPE_p_Mezzanine__XML__NodeText);
24068  }
24069 
24070  result = ((Mezzanine::XML::NodeText const *)arg1)->data();
24071  {
24072  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
24073  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
24074  }
24075  return SWIG_arg;
24076 
24077  if(0) SWIG_fail;
24078 
24079 fail:
24080  lua_error(L);
24081  return SWIG_arg;
24082 }
24083 
24084 
24085 static void swig_delete_NodeText(void *obj) {
24087 delete arg1;
24088 }
24089 static swig_lua_method swig_Mezzanine_XML_NodeText_methods[] = {
24090  {"Empty", _wrap_NodeText_Empty},
24091  {"GetString", _wrap_NodeText_GetString},
24092  {"AsString", _wrap_NodeText_AsString},
24093  {"AsInt", _wrap_NodeText_AsInt},
24094  {"AsUint", _wrap_NodeText_AsUint},
24095  {"AsDouble", _wrap_NodeText_AsDouble},
24096  {"AsFloat", _wrap_NodeText_AsFloat},
24097  {"AsReal", _wrap_NodeText_AsReal},
24098  {"AsWhole", _wrap_NodeText_AsWhole},
24099  {"AsInteger", _wrap_NodeText_AsInteger},
24100  {"AsBool", _wrap_NodeText_AsBool},
24101  {"Set", _wrap_NodeText_Set},
24102  {"data", _wrap_NodeText_data},
24103  {0,0}
24104 };
24105 static swig_lua_attribute swig_Mezzanine_XML_NodeText_attributes[] = {
24106  {0,0,0}
24107 };
24108 static swig_lua_class *swig_Mezzanine_XML_NodeText_bases[] = {0};
24109 static const char *swig_Mezzanine_XML_NodeText_base_names[] = {0};
24110 static swig_lua_class _wrap_class_Mezzanine_XML_NodeText = { "NodeText", &SWIGTYPE_p_Mezzanine__XML__NodeText,_wrap_new_NodeText, swig_delete_NodeText, swig_Mezzanine_XML_NodeText_methods, swig_Mezzanine_XML_NodeText_attributes, swig_Mezzanine_XML_NodeText_bases, swig_Mezzanine_XML_NodeText_base_names };
24111 
24112 static int _wrap_TreeWalker_OnTraversalBegin(lua_State* L) {
24113  int SWIG_arg = 0;
24115  Mezzanine::XML::Node *arg2 = 0 ;
24116  bool result;
24117 
24118  SWIG_check_num_args("Mezzanine::XML::TreeWalker::OnTraversalBegin",2,2)
24119  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::TreeWalker::OnTraversalBegin",1,"Mezzanine::XML::TreeWalker *");
24120  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::TreeWalker::OnTraversalBegin",2,"Mezzanine::XML::Node &");
24121 
24122  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__TreeWalker,0))){
24123  SWIG_fail_ptr("TreeWalker_OnTraversalBegin",1,SWIGTYPE_p_Mezzanine__XML__TreeWalker);
24124  }
24125 
24126 
24127  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Node,0))){
24128  SWIG_fail_ptr("TreeWalker_OnTraversalBegin",2,SWIGTYPE_p_Mezzanine__XML__Node);
24129  }
24130 
24131  result = (bool)(arg1)->OnTraversalBegin(*arg2);
24132  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
24133  return SWIG_arg;
24134 
24135  if(0) SWIG_fail;
24136 
24137 fail:
24138  lua_error(L);
24139  return SWIG_arg;
24140 }
24141 
24142 
24143 static int _wrap_TreeWalker_OnEachNode(lua_State* L) {
24144  int SWIG_arg = 0;
24146  Mezzanine::XML::Node *arg2 = 0 ;
24147  bool result;
24148 
24149  SWIG_check_num_args("Mezzanine::XML::TreeWalker::OnEachNode",2,2)
24150  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::TreeWalker::OnEachNode",1,"Mezzanine::XML::TreeWalker *");
24151  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::TreeWalker::OnEachNode",2,"Mezzanine::XML::Node &");
24152 
24153  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__TreeWalker,0))){
24154  SWIG_fail_ptr("TreeWalker_OnEachNode",1,SWIGTYPE_p_Mezzanine__XML__TreeWalker);
24155  }
24156 
24157 
24158  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Node,0))){
24159  SWIG_fail_ptr("TreeWalker_OnEachNode",2,SWIGTYPE_p_Mezzanine__XML__Node);
24160  }
24161 
24162  result = (bool)(arg1)->OnEachNode(*arg2);
24163  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
24164  return SWIG_arg;
24165 
24166  if(0) SWIG_fail;
24167 
24168 fail:
24169  lua_error(L);
24170  return SWIG_arg;
24171 }
24172 
24173 
24174 static int _wrap_TreeWalker_OnTraversalEnd(lua_State* L) {
24175  int SWIG_arg = 0;
24177  Mezzanine::XML::Node *arg2 = 0 ;
24178  bool result;
24179 
24180  SWIG_check_num_args("Mezzanine::XML::TreeWalker::OnTraversalEnd",2,2)
24181  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::TreeWalker::OnTraversalEnd",1,"Mezzanine::XML::TreeWalker *");
24182  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::TreeWalker::OnTraversalEnd",2,"Mezzanine::XML::Node &");
24183 
24184  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__TreeWalker,0))){
24185  SWIG_fail_ptr("TreeWalker_OnTraversalEnd",1,SWIGTYPE_p_Mezzanine__XML__TreeWalker);
24186  }
24187 
24188 
24189  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Node,0))){
24190  SWIG_fail_ptr("TreeWalker_OnTraversalEnd",2,SWIGTYPE_p_Mezzanine__XML__Node);
24191  }
24192 
24193  result = (bool)(arg1)->OnTraversalEnd(*arg2);
24194  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
24195  return SWIG_arg;
24196 
24197  if(0) SWIG_fail;
24198 
24199 fail:
24200  lua_error(L);
24201  return SWIG_arg;
24202 }
24203 
24204 
24205 static void swig_delete_TreeWalker(void *obj) {
24207 delete arg1;
24208 }
24209 static swig_lua_method swig_Mezzanine_XML_TreeWalker_methods[] = {
24210  {"OnTraversalBegin", _wrap_TreeWalker_OnTraversalBegin},
24211  {"OnEachNode", _wrap_TreeWalker_OnEachNode},
24212  {"OnTraversalEnd", _wrap_TreeWalker_OnTraversalEnd},
24213  {0,0}
24214 };
24215 static swig_lua_attribute swig_Mezzanine_XML_TreeWalker_attributes[] = {
24216  {0,0,0}
24217 };
24218 static swig_lua_class *swig_Mezzanine_XML_TreeWalker_bases[] = {0};
24219 static const char *swig_Mezzanine_XML_TreeWalker_base_names[] = {0};
24220 static swig_lua_class _wrap_class_Mezzanine_XML_TreeWalker = { "TreeWalker", &SWIGTYPE_p_Mezzanine__XML__TreeWalker,0, swig_delete_TreeWalker, swig_Mezzanine_XML_TreeWalker_methods, swig_Mezzanine_XML_TreeWalker_attributes, swig_Mezzanine_XML_TreeWalker_bases, swig_Mezzanine_XML_TreeWalker_base_names };
24221 
24222 static int _wrap_AsUtf8__SWIG_0(lua_State* L) {
24223  int SWIG_arg = 0;
24224  wchar_t *arg1 = (wchar_t *) 0 ;
24225  std::basic_string< char,std::char_traits< char >,std::allocator< char > > result;
24226 
24227  SWIG_check_num_args("Mezzanine::XML::AsUtf8",1,1)
24228  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::AsUtf8",1,"wchar_t const *");
24229 
24230  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_wchar_t,0))){
24231  SWIG_fail_ptr("AsUtf8",1,SWIGTYPE_p_wchar_t);
24232  }
24233 
24234  result = Mezzanine::XML::AsUtf8((wchar_t const *)arg1);
24235  {
24236  std::basic_string< char,std::char_traits< char >,std::allocator< char > > * resultptr = new std::basic_string< char,std::char_traits< char >,std::allocator< char > >((const std::basic_string< char,std::char_traits< char >,std::allocator< char > > &) result);
24237  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,1); SWIG_arg++;
24238  }
24239  return SWIG_arg;
24240 
24241  if(0) SWIG_fail;
24242 
24243 fail:
24244  lua_error(L);
24245  return SWIG_arg;
24246 }
24247 
24248 
24249 static int _wrap_AsUtf8__SWIG_1(lua_State* L) {
24250  int SWIG_arg = 0;
24251  std::basic_string< wchar_t,std::char_traits< wchar_t >,std::allocator< wchar_t > > *arg1 = 0 ;
24252  std::basic_string< char,std::char_traits< char >,std::allocator< char > > result;
24253 
24254  SWIG_check_num_args("Mezzanine::XML::AsUtf8",1,1)
24255  if(!lua_isuserdata(L,1)) SWIG_fail_arg("Mezzanine::XML::AsUtf8",1,"std::basic_string< wchar_t,std::char_traits< wchar_t >,std::allocator< wchar_t > > const &");
24256 
24257  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__basic_stringT_wchar_t_std__char_traitsT_wchar_t_t_std__allocatorT_wchar_t_t_t,0))){
24258  SWIG_fail_ptr("AsUtf8",1,SWIGTYPE_p_std__basic_stringT_wchar_t_std__char_traitsT_wchar_t_t_std__allocatorT_wchar_t_t_t);
24259  }
24260 
24261  result = Mezzanine::XML::AsUtf8((std::basic_string< wchar_t,std::char_traits< wchar_t >,std::allocator< wchar_t > > const &)*arg1);
24262  {
24263  std::basic_string< char,std::char_traits< char >,std::allocator< char > > * resultptr = new std::basic_string< char,std::char_traits< char >,std::allocator< char > >((const std::basic_string< char,std::char_traits< char >,std::allocator< char > > &) result);
24264  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,1); SWIG_arg++;
24265  }
24266  return SWIG_arg;
24267 
24268  if(0) SWIG_fail;
24269 
24270 fail:
24271  lua_error(L);
24272  return SWIG_arg;
24273 }
24274 
24275 
24276 static int _wrap_AsUtf8(lua_State* L) {
24277  int argc;
24278  int argv[2]={
24279  1,2
24280  };
24281 
24282  argc = lua_gettop(L);
24283  if (argc == 1) {
24284  int _v;
24285  {
24286  void *ptr;
24287  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_wchar_t, 0)) {
24288  _v = 0;
24289  } else {
24290  _v = 1;
24291  }
24292  }
24293  if (_v) {
24294  return _wrap_AsUtf8__SWIG_0(L);
24295  }
24296  }
24297  if (argc == 1) {
24298  int _v;
24299  {
24300  void *ptr;
24301  if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__basic_stringT_wchar_t_std__char_traitsT_wchar_t_t_std__allocatorT_wchar_t_t_t, 0)) {
24302  _v = 0;
24303  } else {
24304  _v = 1;
24305  }
24306  }
24307  if (_v) {
24308  return _wrap_AsUtf8__SWIG_1(L);
24309  }
24310  }
24311 
24312  lua_pushstring(L,"Wrong arguments for overloaded function 'AsUtf8'\n"
24313  " Possible C/C++ prototypes are:\n"
24314  " Mezzanine::XML::AsUtf8(wchar_t const *)\n"
24315  " Mezzanine::XML::AsUtf8(std::basic_string< wchar_t,std::char_traits< wchar_t >,std::allocator< wchar_t > > const &)\n");
24316  lua_error(L);return 0;
24317 }
24318 
24319 
24320 static int _wrap_AsWide__SWIG_0(lua_State* L) {
24321  int SWIG_arg = 0;
24322  char *arg1 = (char *) 0 ;
24323  std::basic_string< wchar_t,std::char_traits< wchar_t >,std::allocator< wchar_t > > result;
24324 
24325  SWIG_check_num_args("Mezzanine::XML::AsWide",1,1)
24326  if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("Mezzanine::XML::AsWide",1,"char const *");
24327  arg1 = (char *)lua_tostring(L, 1);
24328  result = Mezzanine::XML::AsWide((char const *)arg1);
24329  {
24330  std::basic_string< wchar_t,std::char_traits< wchar_t >,std::allocator< wchar_t > > * resultptr = new std::basic_string< wchar_t,std::char_traits< wchar_t >,std::allocator< wchar_t > >((const std::basic_string< wchar_t,std::char_traits< wchar_t >,std::allocator< wchar_t > > &) result);
24331  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__basic_stringT_wchar_t_std__char_traitsT_wchar_t_t_std__allocatorT_wchar_t_t_t,1); SWIG_arg++;
24332  }
24333  return SWIG_arg;
24334 
24335  if(0) SWIG_fail;
24336 
24337 fail:
24338  lua_error(L);
24339  return SWIG_arg;
24340 }
24341 
24342 
24343 static int _wrap_AsWide__SWIG_1(lua_State* L) {
24344  int SWIG_arg = 0;
24345  std::basic_string< char,std::char_traits< char >,std::allocator< char > > *arg1 = 0 ;
24346  std::basic_string< wchar_t,std::char_traits< wchar_t >,std::allocator< wchar_t > > result;
24347 
24348  SWIG_check_num_args("Mezzanine::XML::AsWide",1,1)
24349  if(!lua_isuserdata(L,1)) SWIG_fail_arg("Mezzanine::XML::AsWide",1,"std::basic_string< char,std::char_traits< char >,std::allocator< char > > const &");
24350 
24351  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,0))){
24352  SWIG_fail_ptr("AsWide",1,SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t);
24353  }
24354 
24355  result = Mezzanine::XML::AsWide((std::basic_string< char,std::char_traits< char >,std::allocator< char > > const &)*arg1);
24356  {
24357  std::basic_string< wchar_t,std::char_traits< wchar_t >,std::allocator< wchar_t > > * resultptr = new std::basic_string< wchar_t,std::char_traits< wchar_t >,std::allocator< wchar_t > >((const std::basic_string< wchar_t,std::char_traits< wchar_t >,std::allocator< wchar_t > > &) result);
24358  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__basic_stringT_wchar_t_std__char_traitsT_wchar_t_t_std__allocatorT_wchar_t_t_t,1); SWIG_arg++;
24359  }
24360  return SWIG_arg;
24361 
24362  if(0) SWIG_fail;
24363 
24364 fail:
24365  lua_error(L);
24366  return SWIG_arg;
24367 }
24368 
24369 
24370 static int _wrap_AsWide(lua_State* L) {
24371  int argc;
24372  int argv[2]={
24373  1,2
24374  };
24375 
24376  argc = lua_gettop(L);
24377  if (argc == 1) {
24378  int _v;
24379  {
24380  void *ptr;
24381  if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0)) {
24382  _v = 0;
24383  } else {
24384  _v = 1;
24385  }
24386  }
24387  if (_v) {
24388  return _wrap_AsWide__SWIG_1(L);
24389  }
24390  }
24391  if (argc == 1) {
24392  int _v;
24393  {
24394  _v = SWIG_lua_isnilstring(L,argv[0]);
24395  }
24396  if (_v) {
24397  return _wrap_AsWide__SWIG_0(L);
24398  }
24399  }
24400 
24401  lua_pushstring(L,"Wrong arguments for overloaded function 'AsWide'\n"
24402  " Possible C/C++ prototypes are:\n"
24403  " Mezzanine::XML::AsWide(char const *)\n"
24404  " Mezzanine::XML::AsWide(std::basic_string< char,std::char_traits< char >,std::allocator< char > > const &)\n");
24405  lua_error(L);return 0;
24406 }
24407 
24408 
24409 static int _wrap_GetOneTag(lua_State* L) {
24410  int SWIG_arg = 0;
24411  std::istream *arg1 = 0 ;
24412  Mezzanine::String result;
24413 
24414  SWIG_check_num_args("Mezzanine::XML::GetOneTag",1,1)
24415  if(!lua_isuserdata(L,1)) SWIG_fail_arg("Mezzanine::XML::GetOneTag",1,"std::istream &");
24416 
24417  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__istream,0))){
24418  SWIG_fail_ptr("GetOneTag",1,SWIGTYPE_p_std__istream);
24419  }
24420 
24421  result = Mezzanine::XML::GetOneTag(*arg1);
24422  lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
24423  return SWIG_arg;
24424 
24425  if(0) SWIG_fail;
24426 
24427 fail:
24428  lua_error(L);
24429  return SWIG_arg;
24430 }
24431 
24432 
24433 static int _wrap_PreParseClassFromSingleTag__SWIG_0(lua_State* L) {
24434  int SWIG_arg = 0;
24435  Mezzanine::String *arg1 = 0 ;
24436  Mezzanine::String *arg2 = 0 ;
24437  Mezzanine::String *arg3 = 0 ;
24438  Mezzanine::String temp1 ;
24439  Mezzanine::String temp2 ;
24440  Mezzanine::String temp3 ;
24441  Mezzanine::XML::Document *result = 0 ;
24442 
24443  SWIG_check_num_args("Mezzanine::XML::PreParseClassFromSingleTag",3,3)
24444  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::XML::PreParseClassFromSingleTag",1,"Mezzanine::String const &");
24445  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::XML::PreParseClassFromSingleTag",2,"Mezzanine::String const &");
24446  if(!lua_isstring(L,3)) SWIG_fail_arg("Mezzanine::XML::PreParseClassFromSingleTag",3,"Mezzanine::String const &");
24447  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
24448  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
24449  temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3;
24450  result = (Mezzanine::XML::Document *)Mezzanine::XML::PreParseClassFromSingleTag((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
24451  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__XML__Document,0); SWIG_arg++;
24452  return SWIG_arg;
24453 
24454  if(0) SWIG_fail;
24455 
24456 fail:
24457  lua_error(L);
24458  return SWIG_arg;
24459 }
24460 
24461 
24462 static int _wrap_PreParseClassFromSingleTag__SWIG_1(lua_State* L) {
24463  int SWIG_arg = 0;
24464  Mezzanine::String *arg1 = 0 ;
24465  Mezzanine::String *arg2 = 0 ;
24466  Mezzanine::String temp1 ;
24467  Mezzanine::String temp2 ;
24468  Mezzanine::XML::Document *result = 0 ;
24469 
24470  SWIG_check_num_args("Mezzanine::XML::PreParseClassFromSingleTag",2,2)
24471  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::XML::PreParseClassFromSingleTag",1,"Mezzanine::String const &");
24472  if(!lua_isstring(L,2)) SWIG_fail_arg("Mezzanine::XML::PreParseClassFromSingleTag",2,"Mezzanine::String const &");
24473  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
24474  temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2;
24475  result = (Mezzanine::XML::Document *)Mezzanine::XML::PreParseClassFromSingleTag((std::string const &)*arg1,(std::string const &)*arg2);
24476  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__XML__Document,0); SWIG_arg++;
24477  return SWIG_arg;
24478 
24479  if(0) SWIG_fail;
24480 
24481 fail:
24482  lua_error(L);
24483  return SWIG_arg;
24484 }
24485 
24486 
24487 static int _wrap_PreParseClassFromSingleTag(lua_State* L) {
24488  int argc;
24489  int argv[4]={
24490  1,2,3,4
24491  };
24492 
24493  argc = lua_gettop(L);
24494  if (argc == 2) {
24495  int _v;
24496  {
24497  _v = lua_isstring(L,argv[0]);
24498  }
24499  if (_v) {
24500  {
24501  _v = lua_isstring(L,argv[1]);
24502  }
24503  if (_v) {
24504  return _wrap_PreParseClassFromSingleTag__SWIG_1(L);
24505  }
24506  }
24507  }
24508  if (argc == 3) {
24509  int _v;
24510  {
24511  _v = lua_isstring(L,argv[0]);
24512  }
24513  if (_v) {
24514  {
24515  _v = lua_isstring(L,argv[1]);
24516  }
24517  if (_v) {
24518  {
24519  _v = lua_isstring(L,argv[2]);
24520  }
24521  if (_v) {
24522  return _wrap_PreParseClassFromSingleTag__SWIG_0(L);
24523  }
24524  }
24525  }
24526  }
24527 
24528  lua_pushstring(L,"Wrong arguments for overloaded function 'PreParseClassFromSingleTag'\n"
24529  " Possible C/C++ prototypes are:\n"
24530  " Mezzanine::XML::PreParseClassFromSingleTag(Mezzanine::String const &,Mezzanine::String const &,Mezzanine::String const &)\n"
24531  " Mezzanine::XML::PreParseClassFromSingleTag(Mezzanine::String const &,Mezzanine::String const &)\n");
24532  lua_error(L);return 0;
24533 }
24534 
24535 
24536 static int _wrap_EscapeXML(lua_State* L) {
24537  int SWIG_arg = 0;
24538  Mezzanine::String *arg1 = 0 ;
24539  Mezzanine::String temp1 ;
24540  Mezzanine::String result;
24541 
24542  SWIG_check_num_args("Mezzanine::XML::EscapeXML",1,1)
24543  if(!lua_isstring(L,1)) SWIG_fail_arg("Mezzanine::XML::EscapeXML",1,"Mezzanine::String const &");
24544  temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1;
24545  result = Mezzanine::XML::EscapeXML((std::string const &)*arg1);
24546  lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
24547  return SWIG_arg;
24548 
24549  if(0) SWIG_fail;
24550 
24551 fail:
24552  lua_error(L);
24553  return SWIG_arg;
24554 }
24555 
24556 
24557 static int _wrap_new_XPathNode__SWIG_0(lua_State* L) {
24558  int SWIG_arg = 0;
24559  Mezzanine::XML::XPathNode *result = 0 ;
24560 
24561  SWIG_check_num_args("Mezzanine::XML::XPathNode::XPathNode",0,0)
24562  result = (Mezzanine::XML::XPathNode *)new Mezzanine::XML::XPathNode();
24563  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__XML__XPathNode,1); SWIG_arg++;
24564  return SWIG_arg;
24565 
24566  if(0) SWIG_fail;
24567 
24568 fail:
24569  lua_error(L);
24570  return SWIG_arg;
24571 }
24572 
24573 
24574 static int _wrap_new_XPathNode__SWIG_1(lua_State* L) {
24575  int SWIG_arg = 0;
24576  Mezzanine::XML::Node *arg1 = 0 ;
24577  Mezzanine::XML::XPathNode *result = 0 ;
24578 
24579  SWIG_check_num_args("Mezzanine::XML::XPathNode::XPathNode",1,1)
24580  if(!lua_isuserdata(L,1)) SWIG_fail_arg("Mezzanine::XML::XPathNode::XPathNode",1,"Mezzanine::XML::Node const &");
24581 
24582  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Node,0))){
24583  SWIG_fail_ptr("new_XPathNode",1,SWIGTYPE_p_Mezzanine__XML__Node);
24584  }
24585 
24587  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__XML__XPathNode,1); SWIG_arg++;
24588  return SWIG_arg;
24589 
24590  if(0) SWIG_fail;
24591 
24592 fail:
24593  lua_error(L);
24594  return SWIG_arg;
24595 }
24596 
24597 
24598 static int _wrap_new_XPathNode__SWIG_2(lua_State* L) {
24599  int SWIG_arg = 0;
24600  Mezzanine::XML::Attribute *arg1 = 0 ;
24601  Mezzanine::XML::Node *arg2 = 0 ;
24602  Mezzanine::XML::XPathNode *result = 0 ;
24603 
24604  SWIG_check_num_args("Mezzanine::XML::XPathNode::XPathNode",2,2)
24605  if(!lua_isuserdata(L,1)) SWIG_fail_arg("Mezzanine::XML::XPathNode::XPathNode",1,"Mezzanine::XML::Attribute const &");
24606  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::XPathNode::XPathNode",2,"Mezzanine::XML::Node const &");
24607 
24608  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__Attribute,0))){
24609  SWIG_fail_ptr("new_XPathNode",1,SWIGTYPE_p_Mezzanine__XML__Attribute);
24610  }
24611 
24612 
24613  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__Node,0))){
24614  SWIG_fail_ptr("new_XPathNode",2,SWIGTYPE_p_Mezzanine__XML__Node);
24615  }
24616 
24618  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__XML__XPathNode,1); SWIG_arg++;
24619  return SWIG_arg;
24620 
24621  if(0) SWIG_fail;
24622 
24623 fail:
24624  lua_error(L);
24625  return SWIG_arg;
24626 }
24627 
24628 
24629 static int _wrap_new_XPathNode(lua_State* L) {
24630  int argc;
24631  int argv[3]={
24632  1,2,3
24633  };
24634 
24635  argc = lua_gettop(L);
24636  if (argc == 0) {
24637  return _wrap_new_XPathNode__SWIG_0(L);
24638  }
24639  if (argc == 1) {
24640  int _v;
24641  {
24642  void *ptr;
24643  if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
24644  _v = 0;
24645  } else {
24646  _v = 1;
24647  }
24648  }
24649  if (_v) {
24650  return _wrap_new_XPathNode__SWIG_1(L);
24651  }
24652  }
24653  if (argc == 2) {
24654  int _v;
24655  {
24656  void *ptr;
24657  if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Attribute, 0)) {
24658  _v = 0;
24659  } else {
24660  _v = 1;
24661  }
24662  }
24663  if (_v) {
24664  {
24665  void *ptr;
24666  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__Node, 0)) {
24667  _v = 0;
24668  } else {
24669  _v = 1;
24670  }
24671  }
24672  if (_v) {
24673  return _wrap_new_XPathNode__SWIG_2(L);
24674  }
24675  }
24676  }
24677 
24678  lua_pushstring(L,"Wrong arguments for overloaded function 'new_XPathNode'\n"
24679  " Possible C/C++ prototypes are:\n"
24680  " Mezzanine::XML::XPathNode::XPathNode()\n"
24681  " Mezzanine::XML::XPathNode::XPathNode(Mezzanine::XML::Node const &)\n"
24682  " Mezzanine::XML::XPathNode::XPathNode(Mezzanine::XML::Attribute const &,Mezzanine::XML::Node const &)\n");
24683  lua_error(L);return 0;
24684 }
24685 
24686 
24687 static int _wrap_XPathNode_GetNode(lua_State* L) {
24688  int SWIG_arg = 0;
24690  Mezzanine::XML::Node result;
24691 
24692  SWIG_check_num_args("Mezzanine::XML::XPathNode::GetNode",1,1)
24693  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::XPathNode::GetNode",1,"Mezzanine::XML::XPathNode const *");
24694 
24695  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__XPathNode,0))){
24696  SWIG_fail_ptr("XPathNode_GetNode",1,SWIGTYPE_p_Mezzanine__XML__XPathNode);
24697  }
24698 
24699  result = ((Mezzanine::XML::XPathNode const *)arg1)->GetNode();
24700  {
24701  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
24702  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
24703  }
24704  return SWIG_arg;
24705 
24706  if(0) SWIG_fail;
24707 
24708 fail:
24709  lua_error(L);
24710  return SWIG_arg;
24711 }
24712 
24713 
24714 static int _wrap_XPathNode_GetAttribute(lua_State* L) {
24715  int SWIG_arg = 0;
24718 
24719  SWIG_check_num_args("Mezzanine::XML::XPathNode::GetAttribute",1,1)
24720  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::XPathNode::GetAttribute",1,"Mezzanine::XML::XPathNode const *");
24721 
24722  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__XPathNode,0))){
24723  SWIG_fail_ptr("XPathNode_GetAttribute",1,SWIGTYPE_p_Mezzanine__XML__XPathNode);
24724  }
24725 
24726  result = ((Mezzanine::XML::XPathNode const *)arg1)->GetAttribute();
24727  {
24729  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Attribute,1); SWIG_arg++;
24730  }
24731  return SWIG_arg;
24732 
24733  if(0) SWIG_fail;
24734 
24735 fail:
24736  lua_error(L);
24737  return SWIG_arg;
24738 }
24739 
24740 
24741 static int _wrap_XPathNode_GetParent(lua_State* L) {
24742  int SWIG_arg = 0;
24744  Mezzanine::XML::Node result;
24745 
24746  SWIG_check_num_args("Mezzanine::XML::XPathNode::GetParent",1,1)
24747  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::XPathNode::GetParent",1,"Mezzanine::XML::XPathNode const *");
24748 
24749  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__XPathNode,0))){
24750  SWIG_fail_ptr("XPathNode_GetParent",1,SWIGTYPE_p_Mezzanine__XML__XPathNode);
24751  }
24752 
24753  result = ((Mezzanine::XML::XPathNode const *)arg1)->GetParent();
24754  {
24755  Mezzanine::XML::Node * resultptr = new Mezzanine::XML::Node((const Mezzanine::XML::Node &) result);
24756  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__Node,1); SWIG_arg++;
24757  }
24758  return SWIG_arg;
24759 
24760  if(0) SWIG_fail;
24761 
24762 fail:
24763  lua_error(L);
24764  return SWIG_arg;
24765 }
24766 
24767 
24768 static int _wrap_XPathNode___eq(lua_State* L) {
24769  int SWIG_arg = 0;
24771  Mezzanine::XML::XPathNode *arg2 = 0 ;
24772  bool result;
24773 
24774  SWIG_check_num_args("Mezzanine::XML::XPathNode::operator ==",2,2)
24775  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::XPathNode::operator ==",1,"Mezzanine::XML::XPathNode const *");
24776  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::XPathNode::operator ==",2,"Mezzanine::XML::XPathNode const &");
24777 
24778  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__XPathNode,0))){
24779  SWIG_fail_ptr("XPathNode___eq",1,SWIGTYPE_p_Mezzanine__XML__XPathNode);
24780  }
24781 
24782 
24783  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__XPathNode,0))){
24784  SWIG_fail_ptr("XPathNode___eq",2,SWIGTYPE_p_Mezzanine__XML__XPathNode);
24785  }
24786 
24787  result = (bool)((Mezzanine::XML::XPathNode const *)arg1)->operator ==((Mezzanine::XML::XPathNode const &)*arg2);
24788  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
24789  return SWIG_arg;
24790 
24791  if(0) SWIG_fail;
24792 
24793 fail:
24794  lua_error(L);
24795  return SWIG_arg;
24796 }
24797 
24798 
24799 static void swig_delete_XPathNode(void *obj) {
24801 delete arg1;
24802 }
24803 static swig_lua_method swig_Mezzanine_XML_XPathNode_methods[] = {
24804  {"GetNode", _wrap_XPathNode_GetNode},
24805  {"GetAttribute", _wrap_XPathNode_GetAttribute},
24806  {"GetParent", _wrap_XPathNode_GetParent},
24807  {"__eq", _wrap_XPathNode___eq},
24808  {0,0}
24809 };
24810 static swig_lua_attribute swig_Mezzanine_XML_XPathNode_attributes[] = {
24811  {0,0,0}
24812 };
24813 static swig_lua_class *swig_Mezzanine_XML_XPathNode_bases[] = {0};
24814 static const char *swig_Mezzanine_XML_XPathNode_base_names[] = {0};
24815 static swig_lua_class _wrap_class_Mezzanine_XML_XPathNode = { "XPathNode", &SWIGTYPE_p_Mezzanine__XML__XPathNode,_wrap_new_XPathNode, swig_delete_XPathNode, swig_Mezzanine_XML_XPathNode_methods, swig_Mezzanine_XML_XPathNode_attributes, swig_Mezzanine_XML_XPathNode_bases, swig_Mezzanine_XML_XPathNode_base_names };
24816 
24817 static int _wrap_new_XPathNodeSet__SWIG_0(lua_State* L) {
24818  int SWIG_arg = 0;
24819  Mezzanine::XML::XPathNodeSet *result = 0 ;
24820 
24821  SWIG_check_num_args("Mezzanine::XML::XPathNodeSet::XPathNodeSet",0,0)
24822  result = (Mezzanine::XML::XPathNodeSet *)new Mezzanine::XML::XPathNodeSet();
24823  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__XML__XPathNodeSet,1); SWIG_arg++;
24824  return SWIG_arg;
24825 
24826  if(0) SWIG_fail;
24827 
24828 fail:
24829  lua_error(L);
24830  return SWIG_arg;
24831 }
24832 
24833 
24834 static int _wrap_new_XPathNodeSet__SWIG_1(lua_State* L) {
24835  int SWIG_arg = 0;
24839  Mezzanine::XML::XPathNodeSet *result = 0 ;
24840 
24841  SWIG_check_num_args("Mezzanine::XML::XPathNodeSet::XPathNodeSet",3,3)
24842  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::XPathNodeSet::XPathNodeSet",1,"Mezzanine::XML::XPathNodeSet::const_iterator");
24843  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::XML::XPathNodeSet::XPathNodeSet",2,"Mezzanine::XML::XPathNodeSet::const_iterator");
24844  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::XML::XPathNodeSet::XPathNodeSet",3,"Mezzanine::XML::XPathNodeSet::CollectionType");
24845 
24846  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__XPathNode,0))){
24847  SWIG_fail_ptr("new_XPathNodeSet",1,SWIGTYPE_p_Mezzanine__XML__XPathNode);
24848  }
24849 
24850 
24851  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__XPathNode,0))){
24852  SWIG_fail_ptr("new_XPathNodeSet",2,SWIGTYPE_p_Mezzanine__XML__XPathNode);
24853  }
24854 
24855  arg3 = (Mezzanine::XML::XPathNodeSet::CollectionType)(int)lua_tonumber(L, 3);
24856  result = (Mezzanine::XML::XPathNodeSet *)new Mezzanine::XML::XPathNodeSet(arg1,arg2,arg3);
24857  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__XML__XPathNodeSet,1); SWIG_arg++;
24858  return SWIG_arg;
24859 
24860  if(0) SWIG_fail;
24861 
24862 fail:
24863  lua_error(L);
24864  return SWIG_arg;
24865 }
24866 
24867 
24868 static int _wrap_new_XPathNodeSet__SWIG_2(lua_State* L) {
24869  int SWIG_arg = 0;
24872  Mezzanine::XML::XPathNodeSet *result = 0 ;
24873 
24874  SWIG_check_num_args("Mezzanine::XML::XPathNodeSet::XPathNodeSet",2,2)
24875  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::XPathNodeSet::XPathNodeSet",1,"Mezzanine::XML::XPathNodeSet::const_iterator");
24876  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::XML::XPathNodeSet::XPathNodeSet",2,"Mezzanine::XML::XPathNodeSet::const_iterator");
24877 
24878  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__XPathNode,0))){
24879  SWIG_fail_ptr("new_XPathNodeSet",1,SWIGTYPE_p_Mezzanine__XML__XPathNode);
24880  }
24881 
24882 
24883  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__XPathNode,0))){
24884  SWIG_fail_ptr("new_XPathNodeSet",2,SWIGTYPE_p_Mezzanine__XML__XPathNode);
24885  }
24886 
24888  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__XML__XPathNodeSet,1); SWIG_arg++;
24889  return SWIG_arg;
24890 
24891  if(0) SWIG_fail;
24892 
24893 fail:
24894  lua_error(L);
24895  return SWIG_arg;
24896 }
24897 
24898 
24899 static int _wrap_new_XPathNodeSet__SWIG_3(lua_State* L) {
24900  int SWIG_arg = 0;
24901  Mezzanine::XML::XPathNodeSet *arg1 = 0 ;
24902  Mezzanine::XML::XPathNodeSet *result = 0 ;
24903 
24904  SWIG_check_num_args("Mezzanine::XML::XPathNodeSet::XPathNodeSet",1,1)
24905  if(!lua_isuserdata(L,1)) SWIG_fail_arg("Mezzanine::XML::XPathNodeSet::XPathNodeSet",1,"Mezzanine::XML::XPathNodeSet const &");
24906 
24907  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__XPathNodeSet,0))){
24908  SWIG_fail_ptr("new_XPathNodeSet",1,SWIGTYPE_p_Mezzanine__XML__XPathNodeSet);
24909  }
24910 
24912  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__XML__XPathNodeSet,1); SWIG_arg++;
24913  return SWIG_arg;
24914 
24915  if(0) SWIG_fail;
24916 
24917 fail:
24918  lua_error(L);
24919  return SWIG_arg;
24920 }
24921 
24922 
24923 static int _wrap_new_XPathNodeSet(lua_State* L) {
24924  int argc;
24925  int argv[4]={
24926  1,2,3,4
24927  };
24928 
24929  argc = lua_gettop(L);
24930  if (argc == 0) {
24931  return _wrap_new_XPathNodeSet__SWIG_0(L);
24932  }
24933  if (argc == 1) {
24934  int _v;
24935  {
24936  void *ptr;
24937  if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__XPathNodeSet, 0)) {
24938  _v = 0;
24939  } else {
24940  _v = 1;
24941  }
24942  }
24943  if (_v) {
24944  return _wrap_new_XPathNodeSet__SWIG_3(L);
24945  }
24946  }
24947  if (argc == 2) {
24948  int _v;
24949  {
24950  void *ptr;
24951  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__XPathNode, 0)) {
24952  _v = 0;
24953  } else {
24954  _v = 1;
24955  }
24956  }
24957  if (_v) {
24958  {
24959  void *ptr;
24960  if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__XPathNode, 0)) {
24961  _v = 0;
24962  } else {
24963  _v = 1;
24964  }
24965  }
24966  if (_v) {
24967  return _wrap_new_XPathNodeSet__SWIG_2(L);
24968  }
24969  }
24970  }
24971  if (argc == 3) {
24972  int _v;
24973  {
24974  void *ptr;
24975  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__XPathNode, 0)) {
24976  _v = 0;
24977  } else {
24978  _v = 1;
24979  }
24980  }
24981  if (_v) {
24982  {
24983  void *ptr;
24984  if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__XPathNode, 0)) {
24985  _v = 0;
24986  } else {
24987  _v = 1;
24988  }
24989  }
24990  if (_v) {
24991  {
24992  _v = lua_isnumber(L,argv[2]);
24993  }
24994  if (_v) {
24995  return _wrap_new_XPathNodeSet__SWIG_1(L);
24996  }
24997  }
24998  }
24999  }
25000 
25001  lua_pushstring(L,"Wrong arguments for overloaded function 'new_XPathNodeSet'\n"
25002  " Possible C/C++ prototypes are:\n"
25003  " Mezzanine::XML::XPathNodeSet::XPathNodeSet()\n"
25004  " Mezzanine::XML::XPathNodeSet::XPathNodeSet(Mezzanine::XML::XPathNodeSet::const_iterator,Mezzanine::XML::XPathNodeSet::const_iterator,Mezzanine::XML::XPathNodeSet::CollectionType)\n"
25005  " Mezzanine::XML::XPathNodeSet::XPathNodeSet(Mezzanine::XML::XPathNodeSet::const_iterator,Mezzanine::XML::XPathNodeSet::const_iterator)\n"
25006  " Mezzanine::XML::XPathNodeSet::XPathNodeSet(Mezzanine::XML::XPathNodeSet const &)\n");
25007  lua_error(L);return 0;
25008 }
25009 
25010 
25011 static int _wrap_XPathNodeSet_Type(lua_State* L) {
25012  int SWIG_arg = 0;
25015 
25016  SWIG_check_num_args("Mezzanine::XML::XPathNodeSet::Type",1,1)
25017  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::XPathNodeSet::Type",1,"Mezzanine::XML::XPathNodeSet const *");
25018 
25019  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__XPathNodeSet,0))){
25020  SWIG_fail_ptr("XPathNodeSet_Type",1,SWIGTYPE_p_Mezzanine__XML__XPathNodeSet);
25021  }
25022 
25024  lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++;
25025  return SWIG_arg;
25026 
25027  if(0) SWIG_fail;
25028 
25029 fail:
25030  lua_error(L);
25031  return SWIG_arg;
25032 }
25033 
25034 
25035 static int _wrap_XPathNodeSet_size(lua_State* L) {
25036  int SWIG_arg = 0;
25038  size_t result;
25039 
25040  SWIG_check_num_args("Mezzanine::XML::XPathNodeSet::size",1,1)
25041  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::XPathNodeSet::size",1,"Mezzanine::XML::XPathNodeSet const *");
25042 
25043  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__XPathNodeSet,0))){
25044  SWIG_fail_ptr("XPathNodeSet_size",1,SWIGTYPE_p_Mezzanine__XML__XPathNodeSet);
25045  }
25046 
25047  result = ((Mezzanine::XML::XPathNodeSet const *)arg1)->size();
25048  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
25049  return SWIG_arg;
25050 
25051  if(0) SWIG_fail;
25052 
25053 fail:
25054  lua_error(L);
25055  return SWIG_arg;
25056 }
25057 
25058 
25059 static int _wrap_XPathNodeSet_begin(lua_State* L) {
25060  int SWIG_arg = 0;
25063 
25064  SWIG_check_num_args("Mezzanine::XML::XPathNodeSet::begin",1,1)
25065  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::XPathNodeSet::begin",1,"Mezzanine::XML::XPathNodeSet const *");
25066 
25067  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__XPathNodeSet,0))){
25068  SWIG_fail_ptr("XPathNodeSet_begin",1,SWIGTYPE_p_Mezzanine__XML__XPathNodeSet);
25069  }
25070 
25072  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__XML__XPathNode,0); SWIG_arg++;
25073  return SWIG_arg;
25074 
25075  if(0) SWIG_fail;
25076 
25077 fail:
25078  lua_error(L);
25079  return SWIG_arg;
25080 }
25081 
25082 
25083 static int _wrap_XPathNodeSet_end(lua_State* L) {
25084  int SWIG_arg = 0;
25087 
25088  SWIG_check_num_args("Mezzanine::XML::XPathNodeSet::end",1,1)
25089  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::XPathNodeSet::end",1,"Mezzanine::XML::XPathNodeSet const *");
25090 
25091  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__XPathNodeSet,0))){
25092  SWIG_fail_ptr("XPathNodeSet_end",1,SWIGTYPE_p_Mezzanine__XML__XPathNodeSet);
25093  }
25094 
25096  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__XML__XPathNode,0); SWIG_arg++;
25097  return SWIG_arg;
25098 
25099  if(0) SWIG_fail;
25100 
25101 fail:
25102  lua_error(L);
25103  return SWIG_arg;
25104 }
25105 
25106 
25107 static int _wrap_XPathNodeSet_sort__SWIG_0(lua_State* L) {
25108  int SWIG_arg = 0;
25110  bool arg2 ;
25111 
25112  SWIG_check_num_args("Mezzanine::XML::XPathNodeSet::sort",2,2)
25113  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::XPathNodeSet::sort",1,"Mezzanine::XML::XPathNodeSet *");
25114  if(!lua_isboolean(L,2)) SWIG_fail_arg("Mezzanine::XML::XPathNodeSet::sort",2,"bool");
25115 
25116  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__XPathNodeSet,0))){
25117  SWIG_fail_ptr("XPathNodeSet_sort",1,SWIGTYPE_p_Mezzanine__XML__XPathNodeSet);
25118  }
25119 
25120  arg2 = (lua_toboolean(L, 2)!=0);
25121  (arg1)->sort(arg2);
25122 
25123  return SWIG_arg;
25124 
25125  if(0) SWIG_fail;
25126 
25127 fail:
25128  lua_error(L);
25129  return SWIG_arg;
25130 }
25131 
25132 
25133 static int _wrap_XPathNodeSet_sort__SWIG_1(lua_State* L) {
25134  int SWIG_arg = 0;
25136 
25137  SWIG_check_num_args("Mezzanine::XML::XPathNodeSet::sort",1,1)
25138  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::XPathNodeSet::sort",1,"Mezzanine::XML::XPathNodeSet *");
25139 
25140  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__XPathNodeSet,0))){
25141  SWIG_fail_ptr("XPathNodeSet_sort",1,SWIGTYPE_p_Mezzanine__XML__XPathNodeSet);
25142  }
25143 
25144  (arg1)->sort();
25145 
25146  return SWIG_arg;
25147 
25148  if(0) SWIG_fail;
25149 
25150 fail:
25151  lua_error(L);
25152  return SWIG_arg;
25153 }
25154 
25155 
25156 static int _wrap_XPathNodeSet_sort(lua_State* L) {
25157  int argc;
25158  int argv[3]={
25159  1,2,3
25160  };
25161 
25162  argc = lua_gettop(L);
25163  if (argc == 1) {
25164  int _v;
25165  {
25166  void *ptr;
25167  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__XPathNodeSet, 0)) {
25168  _v = 0;
25169  } else {
25170  _v = 1;
25171  }
25172  }
25173  if (_v) {
25174  return _wrap_XPathNodeSet_sort__SWIG_1(L);
25175  }
25176  }
25177  if (argc == 2) {
25178  int _v;
25179  {
25180  void *ptr;
25181  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__XPathNodeSet, 0)) {
25182  _v = 0;
25183  } else {
25184  _v = 1;
25185  }
25186  }
25187  if (_v) {
25188  {
25189  _v = lua_isboolean(L,argv[1]);
25190  }
25191  if (_v) {
25192  return _wrap_XPathNodeSet_sort__SWIG_0(L);
25193  }
25194  }
25195  }
25196 
25197  lua_pushstring(L,"Wrong arguments for overloaded function 'XPathNodeSet_sort'\n"
25198  " Possible C/C++ prototypes are:\n"
25199  " Mezzanine::XML::XPathNodeSet::sort(bool)\n"
25200  " Mezzanine::XML::XPathNodeSet::sort()\n");
25201  lua_error(L);return 0;
25202 }
25203 
25204 
25205 static int _wrap_XPathNodeSet_first(lua_State* L) {
25206  int SWIG_arg = 0;
25209 
25210  SWIG_check_num_args("Mezzanine::XML::XPathNodeSet::first",1,1)
25211  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::XPathNodeSet::first",1,"Mezzanine::XML::XPathNodeSet const *");
25212 
25213  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__XPathNodeSet,0))){
25214  SWIG_fail_ptr("XPathNodeSet_first",1,SWIGTYPE_p_Mezzanine__XML__XPathNodeSet);
25215  }
25216 
25217  result = ((Mezzanine::XML::XPathNodeSet const *)arg1)->first();
25218  {
25220  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__XPathNode,1); SWIG_arg++;
25221  }
25222  return SWIG_arg;
25223 
25224  if(0) SWIG_fail;
25225 
25226 fail:
25227  lua_error(L);
25228  return SWIG_arg;
25229 }
25230 
25231 
25232 static int _wrap_XPathNodeSet_Empty(lua_State* L) {
25233  int SWIG_arg = 0;
25235  bool result;
25236 
25237  SWIG_check_num_args("Mezzanine::XML::XPathNodeSet::Empty",1,1)
25238  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::XPathNodeSet::Empty",1,"Mezzanine::XML::XPathNodeSet const *");
25239 
25240  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__XPathNodeSet,0))){
25241  SWIG_fail_ptr("XPathNodeSet_Empty",1,SWIGTYPE_p_Mezzanine__XML__XPathNodeSet);
25242  }
25243 
25244  result = (bool)((Mezzanine::XML::XPathNodeSet const *)arg1)->Empty();
25245  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
25246  return SWIG_arg;
25247 
25248  if(0) SWIG_fail;
25249 
25250 fail:
25251  lua_error(L);
25252  return SWIG_arg;
25253 }
25254 
25255 
25256 static void swig_delete_XPathNodeSet(void *obj) {
25258 delete arg1;
25259 }
25260 static swig_lua_method swig_Mezzanine_XML_XPathNodeSet_methods[] = {
25261  {"Type", _wrap_XPathNodeSet_Type},
25262  {"size", _wrap_XPathNodeSet_size},
25263  {"begin", _wrap_XPathNodeSet_begin},
25264  {"end", _wrap_XPathNodeSet_end},
25265  {"sort", _wrap_XPathNodeSet_sort},
25266  {"first", _wrap_XPathNodeSet_first},
25267  {"Empty", _wrap_XPathNodeSet_Empty},
25268  {0,0}
25269 };
25270 static swig_lua_attribute swig_Mezzanine_XML_XPathNodeSet_attributes[] = {
25271  {0,0,0}
25272 };
25273 static swig_lua_class *swig_Mezzanine_XML_XPathNodeSet_bases[] = {0};
25274 static const char *swig_Mezzanine_XML_XPathNodeSet_base_names[] = {0};
25275 static swig_lua_class _wrap_class_Mezzanine_XML_XPathNodeSet = { "XPathNodeSet", &SWIGTYPE_p_Mezzanine__XML__XPathNodeSet,_wrap_new_XPathNodeSet, swig_delete_XPathNodeSet, swig_Mezzanine_XML_XPathNodeSet_methods, swig_Mezzanine_XML_XPathNodeSet_attributes, swig_Mezzanine_XML_XPathNodeSet_bases, swig_Mezzanine_XML_XPathNodeSet_base_names };
25276 
25277 static int _wrap_XPathParseResult_Offset_set(lua_State* L) {
25278  int SWIG_arg = 0;
25280  ptrdiff_t arg2 ;
25281  ptrdiff_t *argp2 ;
25282 
25283  SWIG_check_num_args("Mezzanine::XML::XPathParseResult::Offset",2,2)
25284  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::XPathParseResult::Offset",1,"Mezzanine::XML::XPathParseResult *");
25285  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::XPathParseResult::Offset",2,"ptrdiff_t");
25286 
25287  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__XPathParseResult,0))){
25288  SWIG_fail_ptr("XPathParseResult_Offset_set",1,SWIGTYPE_p_Mezzanine__XML__XPathParseResult);
25289  }
25290 
25291 
25292  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ptrdiff_t,0))){
25293  SWIG_fail_ptr("XPathParseResult_Offset_set",2,SWIGTYPE_p_ptrdiff_t);
25294  }
25295  arg2 = *argp2;
25296 
25297  if (arg1) (arg1)->Offset = arg2;
25298 
25299  return SWIG_arg;
25300 
25301  if(0) SWIG_fail;
25302 
25303 fail:
25304  lua_error(L);
25305  return SWIG_arg;
25306 }
25307 
25308 
25309 static int _wrap_XPathParseResult_Offset_get(lua_State* L) {
25310  int SWIG_arg = 0;
25312  ptrdiff_t result;
25313 
25314  SWIG_check_num_args("Mezzanine::XML::XPathParseResult::Offset",1,1)
25315  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::XPathParseResult::Offset",1,"Mezzanine::XML::XPathParseResult *");
25316 
25317  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__XPathParseResult,0))){
25318  SWIG_fail_ptr("XPathParseResult_Offset_get",1,SWIGTYPE_p_Mezzanine__XML__XPathParseResult);
25319  }
25320 
25321  result = ((arg1)->Offset);
25322  {
25323  ptrdiff_t * resultptr = new ptrdiff_t((const ptrdiff_t &) result);
25324  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ptrdiff_t,1); SWIG_arg++;
25325  }
25326  return SWIG_arg;
25327 
25328  if(0) SWIG_fail;
25329 
25330 fail:
25331  lua_error(L);
25332  return SWIG_arg;
25333 }
25334 
25335 
25336 static int _wrap_new_XPathParseResult(lua_State* L) {
25337  int SWIG_arg = 0;
25338  Mezzanine::XML::XPathParseResult *result = 0 ;
25339 
25340  SWIG_check_num_args("Mezzanine::XML::XPathParseResult::XPathParseResult",0,0)
25341  result = (Mezzanine::XML::XPathParseResult *)new Mezzanine::XML::XPathParseResult();
25342  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__XML__XPathParseResult,1); SWIG_arg++;
25343  return SWIG_arg;
25344 
25345  if(0) SWIG_fail;
25346 
25347 fail:
25348  lua_error(L);
25349  return SWIG_arg;
25350 }
25351 
25352 
25353 static int _wrap_XPathParseResult_Description(lua_State* L) {
25354  int SWIG_arg = 0;
25356  char *result = 0 ;
25357 
25358  SWIG_check_num_args("Mezzanine::XML::XPathParseResult::Description",1,1)
25359  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::XPathParseResult::Description",1,"Mezzanine::XML::XPathParseResult const *");
25360 
25361  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__XPathParseResult,0))){
25362  SWIG_fail_ptr("XPathParseResult_Description",1,SWIGTYPE_p_Mezzanine__XML__XPathParseResult);
25363  }
25364 
25365  result = (char *)((Mezzanine::XML::XPathParseResult const *)arg1)->Description();
25366  lua_pushstring(L,(const char *)result); SWIG_arg++;
25367  return SWIG_arg;
25368 
25369  if(0) SWIG_fail;
25370 
25371 fail:
25372  lua_error(L);
25373  return SWIG_arg;
25374 }
25375 
25376 
25377 static void swig_delete_XPathParseResult(void *obj) {
25379 delete arg1;
25380 }
25381 static swig_lua_method swig_Mezzanine_XML_XPathParseResult_methods[] = {
25382  {"Description", _wrap_XPathParseResult_Description},
25383  {0,0}
25384 };
25385 static swig_lua_attribute swig_Mezzanine_XML_XPathParseResult_attributes[] = {
25386  { "Offset", _wrap_XPathParseResult_Offset_get, _wrap_XPathParseResult_Offset_set},
25387  {0,0,0}
25388 };
25389 static swig_lua_class *swig_Mezzanine_XML_XPathParseResult_bases[] = {0};
25390 static const char *swig_Mezzanine_XML_XPathParseResult_base_names[] = {0};
25391 static swig_lua_class _wrap_class_Mezzanine_XML_XPathParseResult = { "XPathParseResult", &SWIGTYPE_p_Mezzanine__XML__XPathParseResult,_wrap_new_XPathParseResult, swig_delete_XPathParseResult, swig_Mezzanine_XML_XPathParseResult_methods, swig_Mezzanine_XML_XPathParseResult_attributes, swig_Mezzanine_XML_XPathParseResult_bases, swig_Mezzanine_XML_XPathParseResult_base_names };
25392 
25393 static int _wrap_XPathVariable_Name(lua_State* L) {
25394  int SWIG_arg = 0;
25396  Mezzanine::Char8 *result = 0 ;
25397 
25398  SWIG_check_num_args("Mezzanine::XML::XPathVariable::Name",1,1)
25399  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::XPathVariable::Name",1,"Mezzanine::XML::XPathVariable const *");
25400 
25401  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__XPathVariable,0))){
25402  SWIG_fail_ptr("XPathVariable_Name",1,SWIGTYPE_p_Mezzanine__XML__XPathVariable);
25403  }
25404 
25405  result = (Mezzanine::Char8 *)((Mezzanine::XML::XPathVariable const *)arg1)->Name();
25406  lua_pushstring(L,(const char *)result); SWIG_arg++;
25407  return SWIG_arg;
25408 
25409  if(0) SWIG_fail;
25410 
25411 fail:
25412  lua_error(L);
25413  return SWIG_arg;
25414 }
25415 
25416 
25417 static int _wrap_XPathVariable_Type(lua_State* L) {
25418  int SWIG_arg = 0;
25421 
25422  SWIG_check_num_args("Mezzanine::XML::XPathVariable::Type",1,1)
25423  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::XPathVariable::Type",1,"Mezzanine::XML::XPathVariable const *");
25424 
25425  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__XPathVariable,0))){
25426  SWIG_fail_ptr("XPathVariable_Type",1,SWIGTYPE_p_Mezzanine__XML__XPathVariable);
25427  }
25428 
25429  result = (Mezzanine::XML::XPathValueType)((Mezzanine::XML::XPathVariable const *)arg1)->Type();
25430  lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++;
25431  return SWIG_arg;
25432 
25433  if(0) SWIG_fail;
25434 
25435 fail:
25436  lua_error(L);
25437  return SWIG_arg;
25438 }
25439 
25440 
25441 static int _wrap_XPathVariable_GetBoole(lua_State* L) {
25442  int SWIG_arg = 0;
25444  bool result;
25445 
25446  SWIG_check_num_args("Mezzanine::XML::XPathVariable::GetBoole",1,1)
25447  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::XPathVariable::GetBoole",1,"Mezzanine::XML::XPathVariable const *");
25448 
25449  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__XPathVariable,0))){
25450  SWIG_fail_ptr("XPathVariable_GetBoole",1,SWIGTYPE_p_Mezzanine__XML__XPathVariable);
25451  }
25452 
25453  result = (bool)((Mezzanine::XML::XPathVariable const *)arg1)->GetBoole();
25454  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
25455  return SWIG_arg;
25456 
25457  if(0) SWIG_fail;
25458 
25459 fail:
25460  lua_error(L);
25461  return SWIG_arg;
25462 }
25463 
25464 
25465 static int _wrap_XPathVariable_GetNumber(lua_State* L) {
25466  int SWIG_arg = 0;
25468  double result;
25469 
25470  SWIG_check_num_args("Mezzanine::XML::XPathVariable::GetNumber",1,1)
25471  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::XPathVariable::GetNumber",1,"Mezzanine::XML::XPathVariable const *");
25472 
25473  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__XPathVariable,0))){
25474  SWIG_fail_ptr("XPathVariable_GetNumber",1,SWIGTYPE_p_Mezzanine__XML__XPathVariable);
25475  }
25476 
25477  result = (double)((Mezzanine::XML::XPathVariable const *)arg1)->GetNumber();
25478  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
25479  return SWIG_arg;
25480 
25481  if(0) SWIG_fail;
25482 
25483 fail:
25484  lua_error(L);
25485  return SWIG_arg;
25486 }
25487 
25488 
25489 static int _wrap_XPathVariable_GetString(lua_State* L) {
25490  int SWIG_arg = 0;
25492  Mezzanine::Char8 *result = 0 ;
25493 
25494  SWIG_check_num_args("Mezzanine::XML::XPathVariable::GetString",1,1)
25495  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::XPathVariable::GetString",1,"Mezzanine::XML::XPathVariable const *");
25496 
25497  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__XPathVariable,0))){
25498  SWIG_fail_ptr("XPathVariable_GetString",1,SWIGTYPE_p_Mezzanine__XML__XPathVariable);
25499  }
25500 
25501  result = (Mezzanine::Char8 *)((Mezzanine::XML::XPathVariable const *)arg1)->GetString();
25502  lua_pushstring(L,(const char *)result); SWIG_arg++;
25503  return SWIG_arg;
25504 
25505  if(0) SWIG_fail;
25506 
25507 fail:
25508  lua_error(L);
25509  return SWIG_arg;
25510 }
25511 
25512 
25513 static int _wrap_XPathVariable_GetNodeSet(lua_State* L) {
25514  int SWIG_arg = 0;
25516  Mezzanine::XML::XPathNodeSet *result = 0 ;
25517 
25518  SWIG_check_num_args("Mezzanine::XML::XPathVariable::GetNodeSet",1,1)
25519  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::XPathVariable::GetNodeSet",1,"Mezzanine::XML::XPathVariable const *");
25520 
25521  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__XPathVariable,0))){
25522  SWIG_fail_ptr("XPathVariable_GetNodeSet",1,SWIGTYPE_p_Mezzanine__XML__XPathVariable);
25523  }
25524 
25525  result = (Mezzanine::XML::XPathNodeSet *) &((Mezzanine::XML::XPathVariable const *)arg1)->GetNodeSet();
25526  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__XML__XPathNodeSet,0); SWIG_arg++;
25527  return SWIG_arg;
25528 
25529  if(0) SWIG_fail;
25530 
25531 fail:
25532  lua_error(L);
25533  return SWIG_arg;
25534 }
25535 
25536 
25537 static int _wrap_XPathVariable_Set__SWIG_0(lua_State* L) {
25538  int SWIG_arg = 0;
25540  bool arg2 ;
25541  bool result;
25542 
25543  SWIG_check_num_args("Mezzanine::XML::XPathVariable::Set",2,2)
25544  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::XPathVariable::Set",1,"Mezzanine::XML::XPathVariable *");
25545  if(!lua_isboolean(L,2)) SWIG_fail_arg("Mezzanine::XML::XPathVariable::Set",2,"bool");
25546 
25547  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__XPathVariable,0))){
25548  SWIG_fail_ptr("XPathVariable_Set",1,SWIGTYPE_p_Mezzanine__XML__XPathVariable);
25549  }
25550 
25551  arg2 = (lua_toboolean(L, 2)!=0);
25552  result = (bool)(arg1)->Set(arg2);
25553  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
25554  return SWIG_arg;
25555 
25556  if(0) SWIG_fail;
25557 
25558 fail:
25559  lua_error(L);
25560  return SWIG_arg;
25561 }
25562 
25563 
25564 static int _wrap_XPathVariable_Set__SWIG_1(lua_State* L) {
25565  int SWIG_arg = 0;
25567  double arg2 ;
25568  bool result;
25569 
25570  SWIG_check_num_args("Mezzanine::XML::XPathVariable::Set",2,2)
25571  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::XPathVariable::Set",1,"Mezzanine::XML::XPathVariable *");
25572  if(!lua_isnumber(L,2)) SWIG_fail_arg("Mezzanine::XML::XPathVariable::Set",2,"double");
25573 
25574  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__XPathVariable,0))){
25575  SWIG_fail_ptr("XPathVariable_Set",1,SWIGTYPE_p_Mezzanine__XML__XPathVariable);
25576  }
25577 
25578  arg2 = (double)lua_tonumber(L, 2);
25579  result = (bool)(arg1)->Set(arg2);
25580  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
25581  return SWIG_arg;
25582 
25583  if(0) SWIG_fail;
25584 
25585 fail:
25586  lua_error(L);
25587  return SWIG_arg;
25588 }
25589 
25590 
25591 static int _wrap_XPathVariable_Set__SWIG_2(lua_State* L) {
25592  int SWIG_arg = 0;
25594  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
25595  bool result;
25596 
25597  SWIG_check_num_args("Mezzanine::XML::XPathVariable::Set",2,2)
25598  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::XPathVariable::Set",1,"Mezzanine::XML::XPathVariable *");
25599  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::XPathVariable::Set",2,"Mezzanine::Char8 const *");
25600 
25601  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__XPathVariable,0))){
25602  SWIG_fail_ptr("XPathVariable_Set",1,SWIGTYPE_p_Mezzanine__XML__XPathVariable);
25603  }
25604 
25605  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
25606  result = (bool)(arg1)->Set((Mezzanine::Char8 const *)arg2);
25607  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
25608  return SWIG_arg;
25609 
25610  if(0) SWIG_fail;
25611 
25612 fail:
25613  lua_error(L);
25614  return SWIG_arg;
25615 }
25616 
25617 
25618 static int _wrap_XPathVariable_Set__SWIG_3(lua_State* L) {
25619  int SWIG_arg = 0;
25621  Mezzanine::XML::XPathNodeSet *arg2 = 0 ;
25622  bool result;
25623 
25624  SWIG_check_num_args("Mezzanine::XML::XPathVariable::Set",2,2)
25625  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::XPathVariable::Set",1,"Mezzanine::XML::XPathVariable *");
25626  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::XPathVariable::Set",2,"Mezzanine::XML::XPathNodeSet const &");
25627 
25628  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__XPathVariable,0))){
25629  SWIG_fail_ptr("XPathVariable_Set",1,SWIGTYPE_p_Mezzanine__XML__XPathVariable);
25630  }
25631 
25632 
25633  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__XPathNodeSet,0))){
25634  SWIG_fail_ptr("XPathVariable_Set",2,SWIGTYPE_p_Mezzanine__XML__XPathNodeSet);
25635  }
25636 
25637  result = (bool)(arg1)->Set((Mezzanine::XML::XPathNodeSet const &)*arg2);
25638  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
25639  return SWIG_arg;
25640 
25641  if(0) SWIG_fail;
25642 
25643 fail:
25644  lua_error(L);
25645  return SWIG_arg;
25646 }
25647 
25648 
25649 static int _wrap_XPathVariable_Set(lua_State* L) {
25650  int argc;
25651  int argv[3]={
25652  1,2,3
25653  };
25654 
25655  argc = lua_gettop(L);
25656  if (argc == 2) {
25657  int _v;
25658  {
25659  void *ptr;
25660  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__XPathVariable, 0)) {
25661  _v = 0;
25662  } else {
25663  _v = 1;
25664  }
25665  }
25666  if (_v) {
25667  {
25668  void *ptr;
25669  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__XPathNodeSet, 0)) {
25670  _v = 0;
25671  } else {
25672  _v = 1;
25673  }
25674  }
25675  if (_v) {
25676  return _wrap_XPathVariable_Set__SWIG_3(L);
25677  }
25678  }
25679  }
25680  if (argc == 2) {
25681  int _v;
25682  {
25683  void *ptr;
25684  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__XPathVariable, 0)) {
25685  _v = 0;
25686  } else {
25687  _v = 1;
25688  }
25689  }
25690  if (_v) {
25691  {
25692  _v = lua_isboolean(L,argv[1]);
25693  }
25694  if (_v) {
25695  return _wrap_XPathVariable_Set__SWIG_0(L);
25696  }
25697  }
25698  }
25699  if (argc == 2) {
25700  int _v;
25701  {
25702  void *ptr;
25703  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__XPathVariable, 0)) {
25704  _v = 0;
25705  } else {
25706  _v = 1;
25707  }
25708  }
25709  if (_v) {
25710  {
25711  _v = lua_isnumber(L,argv[1]);
25712  }
25713  if (_v) {
25714  return _wrap_XPathVariable_Set__SWIG_1(L);
25715  }
25716  }
25717  }
25718  if (argc == 2) {
25719  int _v;
25720  {
25721  void *ptr;
25722  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__XPathVariable, 0)) {
25723  _v = 0;
25724  } else {
25725  _v = 1;
25726  }
25727  }
25728  if (_v) {
25729  {
25730  _v = SWIG_lua_isnilstring(L,argv[1]);
25731  }
25732  if (_v) {
25733  return _wrap_XPathVariable_Set__SWIG_2(L);
25734  }
25735  }
25736  }
25737 
25738  lua_pushstring(L,"Wrong arguments for overloaded function 'XPathVariable_Set'\n"
25739  " Possible C/C++ prototypes are:\n"
25740  " Mezzanine::XML::XPathVariable::Set(bool)\n"
25741  " Mezzanine::XML::XPathVariable::Set(double)\n"
25742  " Mezzanine::XML::XPathVariable::Set(Mezzanine::Char8 const *)\n"
25743  " Mezzanine::XML::XPathVariable::Set(Mezzanine::XML::XPathNodeSet const &)\n");
25744  lua_error(L);return 0;
25745 }
25746 
25747 
25748 static void swig_delete_XPathVariable(void *obj) {
25750 delete arg1;
25751 }
25752 static swig_lua_method swig_Mezzanine_XML_XPathVariable_methods[] = {
25753  {"Name", _wrap_XPathVariable_Name},
25754  {"Type", _wrap_XPathVariable_Type},
25755  {"GetBoole", _wrap_XPathVariable_GetBoole},
25756  {"GetNumber", _wrap_XPathVariable_GetNumber},
25757  {"GetString", _wrap_XPathVariable_GetString},
25758  {"GetNodeSet", _wrap_XPathVariable_GetNodeSet},
25759  {"Set", _wrap_XPathVariable_Set},
25760  {0,0}
25761 };
25762 static swig_lua_attribute swig_Mezzanine_XML_XPathVariable_attributes[] = {
25763  {0,0,0}
25764 };
25765 static swig_lua_class *swig_Mezzanine_XML_XPathVariable_bases[] = {0};
25766 static const char *swig_Mezzanine_XML_XPathVariable_base_names[] = {0};
25767 static swig_lua_class _wrap_class_Mezzanine_XML_XPathVariable = { "XPathVariable", &SWIGTYPE_p_Mezzanine__XML__XPathVariable,0, swig_delete_XPathVariable, swig_Mezzanine_XML_XPathVariable_methods, swig_Mezzanine_XML_XPathVariable_attributes, swig_Mezzanine_XML_XPathVariable_bases, swig_Mezzanine_XML_XPathVariable_base_names };
25768 
25769 static int _wrap_new_XPathVariableSet(lua_State* L) {
25770  int SWIG_arg = 0;
25771  Mezzanine::XML::XPathVariableSet *result = 0 ;
25772 
25773  SWIG_check_num_args("Mezzanine::XML::XPathVariableSet::XPathVariableSet",0,0)
25774  result = (Mezzanine::XML::XPathVariableSet *)new Mezzanine::XML::XPathVariableSet();
25775  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__XML__XPathVariableSet,1); SWIG_arg++;
25776  return SWIG_arg;
25777 
25778  if(0) SWIG_fail;
25779 
25780 fail:
25781  lua_error(L);
25782  return SWIG_arg;
25783 }
25784 
25785 
25786 static int _wrap_XPathVariableSet_Add(lua_State* L) {
25787  int SWIG_arg = 0;
25789  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
25791  Mezzanine::XML::XPathVariable *result = 0 ;
25792 
25793  SWIG_check_num_args("Mezzanine::XML::XPathVariableSet::Add",3,3)
25794  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::XPathVariableSet::Add",1,"Mezzanine::XML::XPathVariableSet *");
25795  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::XPathVariableSet::Add",2,"Mezzanine::Char8 const *");
25796  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::XML::XPathVariableSet::Add",3,"Mezzanine::XML::XPathValueType");
25797 
25798  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__XPathVariableSet,0))){
25799  SWIG_fail_ptr("XPathVariableSet_Add",1,SWIGTYPE_p_Mezzanine__XML__XPathVariableSet);
25800  }
25801 
25802  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
25803  arg3 = (Mezzanine::XML::XPathValueType)(int)lua_tonumber(L, 3);
25804  result = (Mezzanine::XML::XPathVariable *)(arg1)->Add((Mezzanine::Char8 const *)arg2,arg3);
25805  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__XML__XPathVariable,0); SWIG_arg++;
25806  return SWIG_arg;
25807 
25808  if(0) SWIG_fail;
25809 
25810 fail:
25811  lua_error(L);
25812  return SWIG_arg;
25813 }
25814 
25815 
25816 static int _wrap_XPathVariableSet_Set__SWIG_0(lua_State* L) {
25817  int SWIG_arg = 0;
25819  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
25820  bool arg3 ;
25821  bool result;
25822 
25823  SWIG_check_num_args("Mezzanine::XML::XPathVariableSet::Set",3,3)
25824  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::XPathVariableSet::Set",1,"Mezzanine::XML::XPathVariableSet *");
25825  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::XPathVariableSet::Set",2,"Mezzanine::Char8 const *");
25826  if(!lua_isboolean(L,3)) SWIG_fail_arg("Mezzanine::XML::XPathVariableSet::Set",3,"bool");
25827 
25828  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__XPathVariableSet,0))){
25829  SWIG_fail_ptr("XPathVariableSet_Set",1,SWIGTYPE_p_Mezzanine__XML__XPathVariableSet);
25830  }
25831 
25832  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
25833  arg3 = (lua_toboolean(L, 3)!=0);
25834  result = (bool)(arg1)->Set((Mezzanine::Char8 const *)arg2,arg3);
25835  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
25836  return SWIG_arg;
25837 
25838  if(0) SWIG_fail;
25839 
25840 fail:
25841  lua_error(L);
25842  return SWIG_arg;
25843 }
25844 
25845 
25846 static int _wrap_XPathVariableSet_Set__SWIG_1(lua_State* L) {
25847  int SWIG_arg = 0;
25849  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
25850  double arg3 ;
25851  bool result;
25852 
25853  SWIG_check_num_args("Mezzanine::XML::XPathVariableSet::Set",3,3)
25854  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::XPathVariableSet::Set",1,"Mezzanine::XML::XPathVariableSet *");
25855  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::XPathVariableSet::Set",2,"Mezzanine::Char8 const *");
25856  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::XML::XPathVariableSet::Set",3,"double");
25857 
25858  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__XPathVariableSet,0))){
25859  SWIG_fail_ptr("XPathVariableSet_Set",1,SWIGTYPE_p_Mezzanine__XML__XPathVariableSet);
25860  }
25861 
25862  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
25863  arg3 = (double)lua_tonumber(L, 3);
25864  result = (bool)(arg1)->Set((Mezzanine::Char8 const *)arg2,arg3);
25865  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
25866  return SWIG_arg;
25867 
25868  if(0) SWIG_fail;
25869 
25870 fail:
25871  lua_error(L);
25872  return SWIG_arg;
25873 }
25874 
25875 
25876 static int _wrap_XPathVariableSet_Set__SWIG_2(lua_State* L) {
25877  int SWIG_arg = 0;
25879  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
25880  Mezzanine::Char8 *arg3 = (Mezzanine::Char8 *) 0 ;
25881  bool result;
25882 
25883  SWIG_check_num_args("Mezzanine::XML::XPathVariableSet::Set",3,3)
25884  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::XPathVariableSet::Set",1,"Mezzanine::XML::XPathVariableSet *");
25885  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::XPathVariableSet::Set",2,"Mezzanine::Char8 const *");
25886  if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("Mezzanine::XML::XPathVariableSet::Set",3,"Mezzanine::Char8 const *");
25887 
25888  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__XPathVariableSet,0))){
25889  SWIG_fail_ptr("XPathVariableSet_Set",1,SWIGTYPE_p_Mezzanine__XML__XPathVariableSet);
25890  }
25891 
25892  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
25893  arg3 = (Mezzanine::Char8 *)lua_tostring(L, 3);
25894  result = (bool)(arg1)->Set((Mezzanine::Char8 const *)arg2,(Mezzanine::Char8 const *)arg3);
25895  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
25896  return SWIG_arg;
25897 
25898  if(0) SWIG_fail;
25899 
25900 fail:
25901  lua_error(L);
25902  return SWIG_arg;
25903 }
25904 
25905 
25906 static int _wrap_XPathVariableSet_Set__SWIG_3(lua_State* L) {
25907  int SWIG_arg = 0;
25909  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
25910  Mezzanine::XML::XPathNodeSet *arg3 = 0 ;
25911  bool result;
25912 
25913  SWIG_check_num_args("Mezzanine::XML::XPathVariableSet::Set",3,3)
25914  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::XPathVariableSet::Set",1,"Mezzanine::XML::XPathVariableSet *");
25915  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::XPathVariableSet::Set",2,"Mezzanine::Char8 const *");
25916  if(!lua_isuserdata(L,3)) SWIG_fail_arg("Mezzanine::XML::XPathVariableSet::Set",3,"Mezzanine::XML::XPathNodeSet const &");
25917 
25918  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__XPathVariableSet,0))){
25919  SWIG_fail_ptr("XPathVariableSet_Set",1,SWIGTYPE_p_Mezzanine__XML__XPathVariableSet);
25920  }
25921 
25922  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
25923 
25924  if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_Mezzanine__XML__XPathNodeSet,0))){
25925  SWIG_fail_ptr("XPathVariableSet_Set",3,SWIGTYPE_p_Mezzanine__XML__XPathNodeSet);
25926  }
25927 
25928  result = (bool)(arg1)->Set((Mezzanine::Char8 const *)arg2,(Mezzanine::XML::XPathNodeSet const &)*arg3);
25929  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
25930  return SWIG_arg;
25931 
25932  if(0) SWIG_fail;
25933 
25934 fail:
25935  lua_error(L);
25936  return SWIG_arg;
25937 }
25938 
25939 
25940 static int _wrap_XPathVariableSet_Set(lua_State* L) {
25941  int argc;
25942  int argv[4]={
25943  1,2,3,4
25944  };
25945 
25946  argc = lua_gettop(L);
25947  if (argc == 3) {
25948  int _v;
25949  {
25950  void *ptr;
25951  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__XPathVariableSet, 0)) {
25952  _v = 0;
25953  } else {
25954  _v = 1;
25955  }
25956  }
25957  if (_v) {
25958  {
25959  _v = SWIG_lua_isnilstring(L,argv[1]);
25960  }
25961  if (_v) {
25962  {
25963  void *ptr;
25964  if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__XPathNodeSet, 0)) {
25965  _v = 0;
25966  } else {
25967  _v = 1;
25968  }
25969  }
25970  if (_v) {
25971  return _wrap_XPathVariableSet_Set__SWIG_3(L);
25972  }
25973  }
25974  }
25975  }
25976  if (argc == 3) {
25977  int _v;
25978  {
25979  void *ptr;
25980  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__XPathVariableSet, 0)) {
25981  _v = 0;
25982  } else {
25983  _v = 1;
25984  }
25985  }
25986  if (_v) {
25987  {
25988  _v = SWIG_lua_isnilstring(L,argv[1]);
25989  }
25990  if (_v) {
25991  {
25992  _v = lua_isboolean(L,argv[2]);
25993  }
25994  if (_v) {
25995  return _wrap_XPathVariableSet_Set__SWIG_0(L);
25996  }
25997  }
25998  }
25999  }
26000  if (argc == 3) {
26001  int _v;
26002  {
26003  void *ptr;
26004  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__XPathVariableSet, 0)) {
26005  _v = 0;
26006  } else {
26007  _v = 1;
26008  }
26009  }
26010  if (_v) {
26011  {
26012  _v = SWIG_lua_isnilstring(L,argv[1]);
26013  }
26014  if (_v) {
26015  {
26016  _v = lua_isnumber(L,argv[2]);
26017  }
26018  if (_v) {
26019  return _wrap_XPathVariableSet_Set__SWIG_1(L);
26020  }
26021  }
26022  }
26023  }
26024  if (argc == 3) {
26025  int _v;
26026  {
26027  void *ptr;
26028  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__XPathVariableSet, 0)) {
26029  _v = 0;
26030  } else {
26031  _v = 1;
26032  }
26033  }
26034  if (_v) {
26035  {
26036  _v = SWIG_lua_isnilstring(L,argv[1]);
26037  }
26038  if (_v) {
26039  {
26040  _v = SWIG_lua_isnilstring(L,argv[2]);
26041  }
26042  if (_v) {
26043  return _wrap_XPathVariableSet_Set__SWIG_2(L);
26044  }
26045  }
26046  }
26047  }
26048 
26049  lua_pushstring(L,"Wrong arguments for overloaded function 'XPathVariableSet_Set'\n"
26050  " Possible C/C++ prototypes are:\n"
26051  " Mezzanine::XML::XPathVariableSet::Set(Mezzanine::Char8 const *,bool)\n"
26052  " Mezzanine::XML::XPathVariableSet::Set(Mezzanine::Char8 const *,double)\n"
26053  " Mezzanine::XML::XPathVariableSet::Set(Mezzanine::Char8 const *,Mezzanine::Char8 const *)\n"
26054  " Mezzanine::XML::XPathVariableSet::Set(Mezzanine::Char8 const *,Mezzanine::XML::XPathNodeSet const &)\n");
26055  lua_error(L);return 0;
26056 }
26057 
26058 
26059 static int _wrap_XPathVariableSet_Get(lua_State* L) {
26060  int SWIG_arg = 0;
26062  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
26063  Mezzanine::XML::XPathVariable *result = 0 ;
26064 
26065  SWIG_check_num_args("Mezzanine::XML::XPathVariableSet::Get",2,2)
26066  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::XPathVariableSet::Get",1,"Mezzanine::XML::XPathVariableSet *");
26067  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::XPathVariableSet::Get",2,"Mezzanine::Char8 const *");
26068 
26069  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__XPathVariableSet,0))){
26070  SWIG_fail_ptr("XPathVariableSet_Get",1,SWIGTYPE_p_Mezzanine__XML__XPathVariableSet);
26071  }
26072 
26073  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
26074  result = (Mezzanine::XML::XPathVariable *)(arg1)->Get((Mezzanine::Char8 const *)arg2);
26075  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__XML__XPathVariable,0); SWIG_arg++;
26076  return SWIG_arg;
26077 
26078  if(0) SWIG_fail;
26079 
26080 fail:
26081  lua_error(L);
26082  return SWIG_arg;
26083 }
26084 
26085 
26086 static void swig_delete_XPathVariableSet(void *obj) {
26088 delete arg1;
26089 }
26090 static swig_lua_method swig_Mezzanine_XML_XPathVariableSet_methods[] = {
26091  {"Add", _wrap_XPathVariableSet_Add},
26092  {"Set", _wrap_XPathVariableSet_Set},
26093  {"Get", _wrap_XPathVariableSet_Get},
26094  {0,0}
26095 };
26096 static swig_lua_attribute swig_Mezzanine_XML_XPathVariableSet_attributes[] = {
26097  {0,0,0}
26098 };
26099 static swig_lua_class *swig_Mezzanine_XML_XPathVariableSet_bases[] = {0};
26100 static const char *swig_Mezzanine_XML_XPathVariableSet_base_names[] = {0};
26101 static swig_lua_class _wrap_class_Mezzanine_XML_XPathVariableSet = { "XPathVariableSet", &SWIGTYPE_p_Mezzanine__XML__XPathVariableSet,_wrap_new_XPathVariableSet, swig_delete_XPathVariableSet, swig_Mezzanine_XML_XPathVariableSet_methods, swig_Mezzanine_XML_XPathVariableSet_attributes, swig_Mezzanine_XML_XPathVariableSet_bases, swig_Mezzanine_XML_XPathVariableSet_base_names };
26102 
26103 static int _wrap_new_XPathQuery__SWIG_0(lua_State* L) {
26104  int SWIG_arg = 0;
26105  Mezzanine::Char8 *arg1 = (Mezzanine::Char8 *) 0 ;
26107  Mezzanine::XML::XPathQuery *result = 0 ;
26108 
26109  SWIG_check_num_args("Mezzanine::XML::XPathQuery::XPathQuery",2,2)
26110  if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("Mezzanine::XML::XPathQuery::XPathQuery",1,"Mezzanine::Char8 const *");
26111  if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("Mezzanine::XML::XPathQuery::XPathQuery",2,"Mezzanine::XML::XPathVariableSet *");
26112  arg1 = (Mezzanine::Char8 *)lua_tostring(L, 1);
26113 
26114  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__XPathVariableSet,0))){
26115  SWIG_fail_ptr("new_XPathQuery",2,SWIGTYPE_p_Mezzanine__XML__XPathVariableSet);
26116  }
26117 
26118  result = (Mezzanine::XML::XPathQuery *)new Mezzanine::XML::XPathQuery((Mezzanine::Char8 const *)arg1,arg2);
26119  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__XML__XPathQuery,1); SWIG_arg++;
26120  return SWIG_arg;
26121 
26122  if(0) SWIG_fail;
26123 
26124 fail:
26125  lua_error(L);
26126  return SWIG_arg;
26127 }
26128 
26129 
26130 static int _wrap_new_XPathQuery__SWIG_1(lua_State* L) {
26131  int SWIG_arg = 0;
26132  Mezzanine::Char8 *arg1 = (Mezzanine::Char8 *) 0 ;
26133  Mezzanine::XML::XPathQuery *result = 0 ;
26134 
26135  SWIG_check_num_args("Mezzanine::XML::XPathQuery::XPathQuery",1,1)
26136  if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("Mezzanine::XML::XPathQuery::XPathQuery",1,"Mezzanine::Char8 const *");
26137  arg1 = (Mezzanine::Char8 *)lua_tostring(L, 1);
26138  result = (Mezzanine::XML::XPathQuery *)new Mezzanine::XML::XPathQuery((Mezzanine::Char8 const *)arg1);
26139  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__XML__XPathQuery,1); SWIG_arg++;
26140  return SWIG_arg;
26141 
26142  if(0) SWIG_fail;
26143 
26144 fail:
26145  lua_error(L);
26146  return SWIG_arg;
26147 }
26148 
26149 
26150 static int _wrap_new_XPathQuery(lua_State* L) {
26151  int argc;
26152  int argv[3]={
26153  1,2,3
26154  };
26155 
26156  argc = lua_gettop(L);
26157  if (argc == 1) {
26158  int _v;
26159  {
26160  _v = SWIG_lua_isnilstring(L,argv[0]);
26161  }
26162  if (_v) {
26163  return _wrap_new_XPathQuery__SWIG_1(L);
26164  }
26165  }
26166  if (argc == 2) {
26167  int _v;
26168  {
26169  _v = SWIG_lua_isnilstring(L,argv[0]);
26170  }
26171  if (_v) {
26172  {
26173  void *ptr;
26174  if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__XPathVariableSet, 0)) {
26175  _v = 0;
26176  } else {
26177  _v = 1;
26178  }
26179  }
26180  if (_v) {
26181  return _wrap_new_XPathQuery__SWIG_0(L);
26182  }
26183  }
26184  }
26185 
26186  lua_pushstring(L,"Wrong arguments for overloaded function 'new_XPathQuery'\n"
26187  " Possible C/C++ prototypes are:\n"
26188  " Mezzanine::XML::XPathQuery::XPathQuery(Mezzanine::Char8 const *,Mezzanine::XML::XPathVariableSet *)\n"
26189  " Mezzanine::XML::XPathQuery::XPathQuery(Mezzanine::Char8 const *)\n");
26190  lua_error(L);return 0;
26191 }
26192 
26193 
26194 static int _wrap_XPathQuery_ReturnType(lua_State* L) {
26195  int SWIG_arg = 0;
26198 
26199  SWIG_check_num_args("Mezzanine::XML::XPathQuery::ReturnType",1,1)
26200  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::XPathQuery::ReturnType",1,"Mezzanine::XML::XPathQuery const *");
26201 
26202  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__XPathQuery,0))){
26203  SWIG_fail_ptr("XPathQuery_ReturnType",1,SWIGTYPE_p_Mezzanine__XML__XPathQuery);
26204  }
26205 
26206  result = (Mezzanine::XML::XPathValueType)((Mezzanine::XML::XPathQuery const *)arg1)->ReturnType();
26207  lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++;
26208  return SWIG_arg;
26209 
26210  if(0) SWIG_fail;
26211 
26212 fail:
26213  lua_error(L);
26214  return SWIG_arg;
26215 }
26216 
26217 
26218 static int _wrap_XPathQuery_EvaluateBoole(lua_State* L) {
26219  int SWIG_arg = 0;
26221  Mezzanine::XML::XPathNode *arg2 = 0 ;
26222  bool result;
26223 
26224  SWIG_check_num_args("Mezzanine::XML::XPathQuery::EvaluateBoole",2,2)
26225  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::XPathQuery::EvaluateBoole",1,"Mezzanine::XML::XPathQuery const *");
26226  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::XPathQuery::EvaluateBoole",2,"Mezzanine::XML::XPathNode const &");
26227 
26228  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__XPathQuery,0))){
26229  SWIG_fail_ptr("XPathQuery_EvaluateBoole",1,SWIGTYPE_p_Mezzanine__XML__XPathQuery);
26230  }
26231 
26232 
26233  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__XPathNode,0))){
26234  SWIG_fail_ptr("XPathQuery_EvaluateBoole",2,SWIGTYPE_p_Mezzanine__XML__XPathNode);
26235  }
26236 
26237  result = (bool)((Mezzanine::XML::XPathQuery const *)arg1)->EvaluateBoole((Mezzanine::XML::XPathNode const &)*arg2);
26238  lua_pushboolean(L,(int)(result!=0)); SWIG_arg++;
26239  return SWIG_arg;
26240 
26241  if(0) SWIG_fail;
26242 
26243 fail:
26244  lua_error(L);
26245  return SWIG_arg;
26246 }
26247 
26248 
26249 static int _wrap_XPathQuery_EvaluateNumber(lua_State* L) {
26250  int SWIG_arg = 0;
26252  Mezzanine::XML::XPathNode *arg2 = 0 ;
26253  double result;
26254 
26255  SWIG_check_num_args("Mezzanine::XML::XPathQuery::EvaluateNumber",2,2)
26256  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::XPathQuery::EvaluateNumber",1,"Mezzanine::XML::XPathQuery const *");
26257  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::XPathQuery::EvaluateNumber",2,"Mezzanine::XML::XPathNode const &");
26258 
26259  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__XPathQuery,0))){
26260  SWIG_fail_ptr("XPathQuery_EvaluateNumber",1,SWIGTYPE_p_Mezzanine__XML__XPathQuery);
26261  }
26262 
26263 
26264  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__XPathNode,0))){
26265  SWIG_fail_ptr("XPathQuery_EvaluateNumber",2,SWIGTYPE_p_Mezzanine__XML__XPathNode);
26266  }
26267 
26268  result = (double)((Mezzanine::XML::XPathQuery const *)arg1)->EvaluateNumber((Mezzanine::XML::XPathNode const &)*arg2);
26269  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
26270  return SWIG_arg;
26271 
26272  if(0) SWIG_fail;
26273 
26274 fail:
26275  lua_error(L);
26276  return SWIG_arg;
26277 }
26278 
26279 
26280 static int _wrap_XPathQuery_EvaluateString__SWIG_0(lua_State* L) {
26281  int SWIG_arg = 0;
26283  Mezzanine::XML::XPathNode *arg2 = 0 ;
26284  Mezzanine::String result;
26285 
26286  SWIG_check_num_args("Mezzanine::XML::XPathQuery::EvaluateString",2,2)
26287  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::XPathQuery::EvaluateString",1,"Mezzanine::XML::XPathQuery const *");
26288  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::XPathQuery::EvaluateString",2,"Mezzanine::XML::XPathNode const &");
26289 
26290  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__XPathQuery,0))){
26291  SWIG_fail_ptr("XPathQuery_EvaluateString",1,SWIGTYPE_p_Mezzanine__XML__XPathQuery);
26292  }
26293 
26294 
26295  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__XPathNode,0))){
26296  SWIG_fail_ptr("XPathQuery_EvaluateString",2,SWIGTYPE_p_Mezzanine__XML__XPathNode);
26297  }
26298 
26299  result = ((Mezzanine::XML::XPathQuery const *)arg1)->EvaluateString((Mezzanine::XML::XPathNode const &)*arg2);
26300  lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++;
26301  return SWIG_arg;
26302 
26303  if(0) SWIG_fail;
26304 
26305 fail:
26306  lua_error(L);
26307  return SWIG_arg;
26308 }
26309 
26310 
26311 static int _wrap_XPathQuery_EvaluateString__SWIG_1(lua_State* L) {
26312  int SWIG_arg = 0;
26314  Mezzanine::Char8 *arg2 = (Mezzanine::Char8 *) 0 ;
26315  size_t arg3 ;
26316  Mezzanine::XML::XPathNode *arg4 = 0 ;
26317  size_t result;
26318 
26319  SWIG_check_num_args("Mezzanine::XML::XPathQuery::EvaluateString",4,4)
26320  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::XPathQuery::EvaluateString",1,"Mezzanine::XML::XPathQuery const *");
26321  if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("Mezzanine::XML::XPathQuery::EvaluateString",2,"Mezzanine::Char8 *");
26322  if(!lua_isnumber(L,3)) SWIG_fail_arg("Mezzanine::XML::XPathQuery::EvaluateString",3,"size_t");
26323  if(!lua_isuserdata(L,4)) SWIG_fail_arg("Mezzanine::XML::XPathQuery::EvaluateString",4,"Mezzanine::XML::XPathNode const &");
26324 
26325  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__XPathQuery,0))){
26326  SWIG_fail_ptr("XPathQuery_EvaluateString",1,SWIGTYPE_p_Mezzanine__XML__XPathQuery);
26327  }
26328 
26329  arg2 = (Mezzanine::Char8 *)lua_tostring(L, 2);
26330  SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative")
26331  arg3 = (size_t)lua_tonumber(L, 3);
26332 
26333  if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_Mezzanine__XML__XPathNode,0))){
26334  SWIG_fail_ptr("XPathQuery_EvaluateString",4,SWIGTYPE_p_Mezzanine__XML__XPathNode);
26335  }
26336 
26337  result = ((Mezzanine::XML::XPathQuery const *)arg1)->EvaluateString(arg2,arg3,(Mezzanine::XML::XPathNode const &)*arg4);
26338  lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
26339  return SWIG_arg;
26340 
26341  if(0) SWIG_fail;
26342 
26343 fail:
26344  lua_error(L);
26345  return SWIG_arg;
26346 }
26347 
26348 
26349 static int _wrap_XPathQuery_EvaluateString(lua_State* L) {
26350  int argc;
26351  int argv[5]={
26352  1,2,3,4,5
26353  };
26354 
26355  argc = lua_gettop(L);
26356  if (argc == 2) {
26357  int _v;
26358  {
26359  void *ptr;
26360  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__XPathQuery, 0)) {
26361  _v = 0;
26362  } else {
26363  _v = 1;
26364  }
26365  }
26366  if (_v) {
26367  {
26368  void *ptr;
26369  if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__XPathNode, 0)) {
26370  _v = 0;
26371  } else {
26372  _v = 1;
26373  }
26374  }
26375  if (_v) {
26376  return _wrap_XPathQuery_EvaluateString__SWIG_0(L);
26377  }
26378  }
26379  }
26380  if (argc == 4) {
26381  int _v;
26382  {
26383  void *ptr;
26384  if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__XPathQuery, 0)) {
26385  _v = 0;
26386  } else {
26387  _v = 1;
26388  }
26389  }
26390  if (_v) {
26391  {
26392  _v = SWIG_lua_isnilstring(L,argv[1]);
26393  }
26394  if (_v) {
26395  {
26396  _v = lua_isnumber(L,argv[2]);
26397  }
26398  if (_v) {
26399  {
26400  void *ptr;
26401  if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_Mezzanine__XML__XPathNode, 0)) {
26402  _v = 0;
26403  } else {
26404  _v = 1;
26405  }
26406  }
26407  if (_v) {
26408  return _wrap_XPathQuery_EvaluateString__SWIG_1(L);
26409  }
26410  }
26411  }
26412  }
26413  }
26414 
26415  lua_pushstring(L,"Wrong arguments for overloaded function 'XPathQuery_EvaluateString'\n"
26416  " Possible C/C++ prototypes are:\n"
26417  " Mezzanine::XML::XPathQuery::EvaluateString(Mezzanine::XML::XPathNode const &) const\n"
26418  " Mezzanine::XML::XPathQuery::EvaluateString(Mezzanine::Char8 *,size_t,Mezzanine::XML::XPathNode const &) const\n");
26419  lua_error(L);return 0;
26420 }
26421 
26422 
26423 static int _wrap_XPathQuery_EvaluateNodeSet(lua_State* L) {
26424  int SWIG_arg = 0;
26426  Mezzanine::XML::XPathNode *arg2 = 0 ;
26428 
26429  SWIG_check_num_args("Mezzanine::XML::XPathQuery::EvaluateNodeSet",2,2)
26430  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::XPathQuery::EvaluateNodeSet",1,"Mezzanine::XML::XPathQuery const *");
26431  if(!lua_isuserdata(L,2)) SWIG_fail_arg("Mezzanine::XML::XPathQuery::EvaluateNodeSet",2,"Mezzanine::XML::XPathNode const &");
26432 
26433  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__XPathQuery,0))){
26434  SWIG_fail_ptr("XPathQuery_EvaluateNodeSet",1,SWIGTYPE_p_Mezzanine__XML__XPathQuery);
26435  }
26436 
26437 
26438  if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_Mezzanine__XML__XPathNode,0))){
26439  SWIG_fail_ptr("XPathQuery_EvaluateNodeSet",2,SWIGTYPE_p_Mezzanine__XML__XPathNode);
26440  }
26441 
26442  result = ((Mezzanine::XML::XPathQuery const *)arg1)->EvaluateNodeSet((Mezzanine::XML::XPathNode const &)*arg2);
26443  {
26445  SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_Mezzanine__XML__XPathNodeSet,1); SWIG_arg++;
26446  }
26447  return SWIG_arg;
26448 
26449  if(0) SWIG_fail;
26450 
26451 fail:
26452  lua_error(L);
26453  return SWIG_arg;
26454 }
26455 
26456 
26457 static int _wrap_XPathQuery_Result(lua_State* L) {
26458  int SWIG_arg = 0;
26460  Mezzanine::XML::XPathParseResult *result = 0 ;
26461 
26462  SWIG_check_num_args("Mezzanine::XML::XPathQuery::Result",1,1)
26463  if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("Mezzanine::XML::XPathQuery::Result",1,"Mezzanine::XML::XPathQuery const *");
26464 
26465  if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_Mezzanine__XML__XPathQuery,0))){
26466  SWIG_fail_ptr("XPathQuery_Result",1,SWIGTYPE_p_Mezzanine__XML__XPathQuery);
26467  }
26468 
26469  result = (Mezzanine::XML::XPathParseResult *) &((Mezzanine::XML::XPathQuery const *)arg1)->Result();
26470  SWIG_NewPointerObj(L,result,SWIGTYPE_p_Mezzanine__XML__XPathParseResult,0); SWIG_arg++;
26471  return SWIG_arg;
26472 
26473  if(0) SWIG_fail;
26474 
26475 fail:
26476  lua_error(L);
26477  return SWIG_arg;
26478 }
26479 
26480 
26481 static void swig_delete_XPathQuery(void *obj) {
26483 delete arg1;
26484 }
26485 static swig_lua_method swig_Mezzanine_XML_XPathQuery_methods[] = {
26486  {"ReturnType", _wrap_XPathQuery_ReturnType},
26487  {"EvaluateBoole", _wrap_XPathQuery_EvaluateBoole},
26488  {"EvaluateNumber", _wrap_XPathQuery_EvaluateNumber},
26489  {"EvaluateString", _wrap_XPathQuery_EvaluateString},
26490  {"EvaluateNodeSet", _wrap_XPathQuery_EvaluateNodeSet},
26491  {"Result", _wrap_XPathQuery_Result},
26492  {0,0}
26493 };
26494 static swig_lua_attribute swig_Mezzanine_XML_XPathQuery_attributes[] = {
26495  {0,0,0}
26496 };
26497 static swig_lua_class *swig_Mezzanine_XML_XPathQuery_bases[] = {0};
26498 static const char *swig_Mezzanine_XML_XPathQuery_base_names[] = {0};
26499 static swig_lua_class _wrap_class_Mezzanine_XML_XPathQuery = { "XPathQuery", &SWIGTYPE_p_Mezzanine__XML__XPathQuery,_wrap_new_XPathQuery, swig_delete_XPathQuery, swig_Mezzanine_XML_XPathQuery_methods, swig_Mezzanine_XML_XPathQuery_attributes, swig_Mezzanine_XML_XPathQuery_bases, swig_Mezzanine_XML_XPathQuery_base_names };
26500 
26501 #ifdef __cplusplus
26502 }
26503 #endif
26504 
26505 static const struct luaL_Reg swig_commands[] = {
26506  { "SetMemoryManagementFunctions", _wrap_SetMemoryManagementFunctions},
26507  { "GetMemoryAllocationFunction", _wrap_GetMemoryAllocationFunction},
26508  { "GetMemoryDeallocationFunction", _wrap_GetMemoryDeallocationFunction},
26509  { "AsUtf8",_wrap_AsUtf8},
26510  { "AsWide",_wrap_AsWide},
26511  { "GetOneTag", _wrap_GetOneTag},
26512  { "PreParseClassFromSingleTag",_wrap_PreParseClassFromSingleTag},
26513  { "EscapeXML", _wrap_EscapeXML},
26514  {0,0}
26515 };
26516 
26517 static swig_lua_var_info swig_variables[] = {
26518  { "ParseMinimal", _wrap_ParseMinimal_get, SWIG_Lua_set_immutable },
26519  { "ParsePi", _wrap_ParsePi_get, SWIG_Lua_set_immutable },
26520  { "ParseComments", _wrap_ParseComments_get, SWIG_Lua_set_immutable },
26521  { "ParseCdata", _wrap_ParseCdata_get, SWIG_Lua_set_immutable },
26522  { "ParseWsPcdata", _wrap_ParseWsPcdata_get, SWIG_Lua_set_immutable },
26523  { "ParseEscapes", _wrap_ParseEscapes_get, SWIG_Lua_set_immutable },
26524  { "ParseEol", _wrap_ParseEol_get, SWIG_Lua_set_immutable },
26525  { "ParseWconvAttribute", _wrap_ParseWconvAttribute_get, SWIG_Lua_set_immutable },
26526  { "ParseWnormAttribute", _wrap_ParseWnormAttribute_get, SWIG_Lua_set_immutable },
26527  { "ParseDeclaration", _wrap_ParseDeclaration_get, SWIG_Lua_set_immutable },
26528  { "ParseDocType", _wrap_ParseDocType_get, SWIG_Lua_set_immutable },
26529  { "ParseWsPcdata_single", _wrap_ParseWsPcdata_single_get, SWIG_Lua_set_immutable },
26530  { "ParseDefault", _wrap_ParseDefault_get, SWIG_Lua_set_immutable },
26531  { "ParseFull", _wrap_ParseFull_get, SWIG_Lua_set_immutable },
26532  { "FormatIndent", _wrap_FormatIndent_get, SWIG_Lua_set_immutable },
26533  { "FormatWriteBom", _wrap_FormatWriteBom_get, SWIG_Lua_set_immutable },
26534  { "FormatRaw", _wrap_FormatRaw_get, SWIG_Lua_set_immutable },
26535  { "FormatNoDeclaration", _wrap_FormatNoDeclaration_get, SWIG_Lua_set_immutable },
26536  { "FormatNoEscapes", _wrap_FormatNoEscapes_get, SWIG_Lua_set_immutable },
26537  { "FormatSaveFileText", _wrap_FormatSaveFileText_get, SWIG_Lua_set_immutable },
26538  { "FormatDefault", _wrap_FormatDefault_get, SWIG_Lua_set_immutable },
26539  {0,0,0}
26540 };
26541 
26542 static swig_lua_const_info swig_constants[] = {
26543  {SWIG_LUA_CONSTTAB_INT("XML_VERSION", 100)},
26544  {SWIG_LUA_CONSTTAB_INT("MEZZANINE_CORE", 1)},
26545  {SWIG_LUA_CONSTTAB_INT("MEZZ_FRAMESTOTRACK", 10)},
26546  {SWIG_LUA_CONSTTAB_INT("EncodingAuto", Mezzanine::XML::EncodingAuto)},
26547  {SWIG_LUA_CONSTTAB_INT("EncodingUTF8", Mezzanine::XML::EncodingUTF8)},
26548  {SWIG_LUA_CONSTTAB_INT("EncodingUTF16LE", Mezzanine::XML::EncodingUTF16LE)},
26549  {SWIG_LUA_CONSTTAB_INT("EncodingUTF16BE", Mezzanine::XML::EncodingUTF16BE)},
26550  {SWIG_LUA_CONSTTAB_INT("EncodingUTF16", Mezzanine::XML::EncodingUTF16)},
26551  {SWIG_LUA_CONSTTAB_INT("EncodingUTF32LE", Mezzanine::XML::EncodingUTF32LE)},
26552  {SWIG_LUA_CONSTTAB_INT("EncodingUTF32BE", Mezzanine::XML::EncodingUTF32BE)},
26553  {SWIG_LUA_CONSTTAB_INT("EncodingUTF32", Mezzanine::XML::EncodingUTF32)},
26554  {SWIG_LUA_CONSTTAB_INT("Encodingwchar_t", Mezzanine::XML::Encodingwchar_t)},
26555  {SWIG_LUA_CONSTTAB_INT("EncodingLatin1", Mezzanine::XML::EncodingLatin1)},
26556  {SWIG_LUA_CONSTTAB_INT("NodeNull", Mezzanine::XML::NodeNull)},
26557  {SWIG_LUA_CONSTTAB_INT("NodeDocument", Mezzanine::XML::NodeDocument)},
26558  {SWIG_LUA_CONSTTAB_INT("NodeElement", Mezzanine::XML::NodeElement)},
26559  {SWIG_LUA_CONSTTAB_INT("NodePcdata", Mezzanine::XML::NodePcdata)},
26560  {SWIG_LUA_CONSTTAB_INT("NodeCdata", Mezzanine::XML::NodeCdata)},
26561  {SWIG_LUA_CONSTTAB_INT("NodeComment", Mezzanine::XML::NodeComment)},
26562  {SWIG_LUA_CONSTTAB_INT("NodePi", Mezzanine::XML::NodePi)},
26563  {SWIG_LUA_CONSTTAB_INT("NodeDeclaration", Mezzanine::XML::NodeDeclaration)},
26564  {SWIG_LUA_CONSTTAB_INT("NodeDocType", Mezzanine::XML::NodeDocType)},
26565  {SWIG_LUA_CONSTTAB_INT("StatusOk", Mezzanine::XML::StatusOk)},
26566  {SWIG_LUA_CONSTTAB_INT("StatusFileNotFound", Mezzanine::XML::StatusFileNotFound)},
26567  {SWIG_LUA_CONSTTAB_INT("StatusIOError", Mezzanine::XML::StatusIOError)},
26568  {SWIG_LUA_CONSTTAB_INT("StatusOutOfMemory", Mezzanine::XML::StatusOutOfMemory)},
26569  {SWIG_LUA_CONSTTAB_INT("StatusInternalError", Mezzanine::XML::StatusInternalError)},
26570  {SWIG_LUA_CONSTTAB_INT("StatusUnrecognizedTag", Mezzanine::XML::StatusUnrecognizedTag)},
26571  {SWIG_LUA_CONSTTAB_INT("StatusBadProcessingInstruction", Mezzanine::XML::StatusBadProcessingInstruction)},
26572  {SWIG_LUA_CONSTTAB_INT("StatusBadComment", Mezzanine::XML::StatusBadComment)},
26573  {SWIG_LUA_CONSTTAB_INT("StatusBadCdata", Mezzanine::XML::StatusBadCdata)},
26574  {SWIG_LUA_CONSTTAB_INT("StatusBadDocType", Mezzanine::XML::StatusBadDocType)},
26575  {SWIG_LUA_CONSTTAB_INT("StatusBadPcdata", Mezzanine::XML::StatusBadPcdata)},
26576  {SWIG_LUA_CONSTTAB_INT("StatusBadStartElement", Mezzanine::XML::StatusBadStartElement)},
26577  {SWIG_LUA_CONSTTAB_INT("StatusBadAttribute", Mezzanine::XML::StatusBadAttribute)},
26578  {SWIG_LUA_CONSTTAB_INT("StatusBadEndElement", Mezzanine::XML::StatusBadEndElement)},
26579  {SWIG_LUA_CONSTTAB_INT("StatusEndElementMismatch", Mezzanine::XML::StatusEndElementMismatch)},
26580  {SWIG_LUA_CONSTTAB_INT("XPathTypeNone", Mezzanine::XML::XPathTypeNone)},
26581  {SWIG_LUA_CONSTTAB_INT("XPathTypeNodeSet", Mezzanine::XML::XPathTypeNodeSet)},
26582  {SWIG_LUA_CONSTTAB_INT("XPathTypeNumber", Mezzanine::XML::XPathTypeNumber)},
26583  {SWIG_LUA_CONSTTAB_INT("XPathTypeString", Mezzanine::XML::XPathTypeString)},
26584  {SWIG_LUA_CONSTTAB_INT("XPathTypeBoole", Mezzanine::XML::XPathTypeBoole)},
26585  {SWIG_LUA_CONSTTAB_INT("XPathNodeSet_TypeUnsorted", Mezzanine::XML::XPathNodeSet::TypeUnsorted)},
26586  {SWIG_LUA_CONSTTAB_INT("XPathNodeSet_TypeSorted", Mezzanine::XML::XPathNodeSet::TypeSorted)},
26587  {SWIG_LUA_CONSTTAB_INT("XPathNodeSet_TypeSortedReverse", Mezzanine::XML::XPathNodeSet::TypeSortedReverse)},
26588  {0,0,0,0,0,0}
26589 };
26590 
26591 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
26592 
26593 static void *_p_Mezzanine__XML__XMLStreamWrapperTo_p_Mezzanine__XML__Writer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26594  return (void *)((Mezzanine::XML::Writer *) ((Mezzanine::XML::XMLStreamWrapper *) x));
26595 }
26596 static void *_p_Mezzanine__XML__WriterFileTo_p_Mezzanine__XML__Writer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26597  return (void *)((Mezzanine::XML::Writer *) ((Mezzanine::XML::WriterFile *) x));
26598 }
26599 static void *_p_Mezzanine__XML__WriterStreamTo_p_Mezzanine__XML__Writer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26600  return (void *)((Mezzanine::XML::Writer *) ((Mezzanine::XML::WriterStream *) x));
26601 }
26602 static void *_p_Mezzanine__XML__DocumentTo_p_Mezzanine__XML__Node(void *x, int *SWIGUNUSEDPARM(newmemory)) {
26603  return (void *)((Mezzanine::XML::Node *) ((Mezzanine::XML::Document *) x));
26604 }
26605 static swig_type_info _swigt__p_Mezzanine__Threading__RawFile = {"_p_Mezzanine__Threading__RawFile", "Mezzanine::Threading::RawFile *|Mezzanine::RawFile *", 0, 0, (void*)0, 0};
26606 static swig_type_info _swigt__p_Mezzanine__Vector3 = {"_p_Mezzanine__Vector3", "Mezzanine::Vector3 *|Mezzanine::Physics::Vector3 *", 0, 0, (void*)0, 0};
26607 static swig_type_info _swigt__p_Mezzanine__XML__Attribute = {"_p_Mezzanine__XML__Attribute", "Mezzanine::XML::Attribute *", 0, 0, (void*)&_wrap_class_Mezzanine_XML_Attribute, 0};
26608 static swig_type_info _swigt__p_Mezzanine__XML__AttributeIterator = {"_p_Mezzanine__XML__AttributeIterator", "Mezzanine::XML::AttributeIterator *|Mezzanine::XML::Node::attribute_iterator *", 0, 0, (void*)&_wrap_class_Mezzanine_XML_AttributeIterator, 0};
26609 static swig_type_info _swigt__p_Mezzanine__XML__AttributeStruct = {"_p_Mezzanine__XML__AttributeStruct", "Mezzanine::XML::AttributeStruct *", 0, 0, (void*)0, 0};
26610 static swig_type_info _swigt__p_Mezzanine__XML__Document = {"_p_Mezzanine__XML__Document", "Mezzanine::XML::Document *", 0, 0, (void*)&_wrap_class_Mezzanine_XML_Document, 0};
26611 static swig_type_info _swigt__p_Mezzanine__XML__NamedNodeIterator = {"_p_Mezzanine__XML__NamedNodeIterator", "Mezzanine::XML::NamedNodeIterator *", 0, 0, (void*)&_wrap_class_Mezzanine_XML_NamedNodeIterator, 0};
26612 static swig_type_info _swigt__p_Mezzanine__XML__Node = {"_p_Mezzanine__XML__Node", "Mezzanine::XML::Node *", 0, 0, (void*)&_wrap_class_Mezzanine_XML_Node, 0};
26613 static swig_type_info _swigt__p_Mezzanine__XML__NodeIterator = {"_p_Mezzanine__XML__NodeIterator", "Mezzanine::XML::NodeIterator *|Mezzanine::XML::Node::iterator *", 0, 0, (void*)&_wrap_class_Mezzanine_XML_NodeIterator, 0};
26614 static swig_type_info _swigt__p_Mezzanine__XML__NodeStruct = {"_p_Mezzanine__XML__NodeStruct", "Mezzanine::XML::NodeStruct *", 0, 0, (void*)0, 0};
26615 static swig_type_info _swigt__p_Mezzanine__XML__NodeText = {"_p_Mezzanine__XML__NodeText", "Mezzanine::XML::NodeText *", 0, 0, (void*)&_wrap_class_Mezzanine_XML_NodeText, 0};
26616 static swig_type_info _swigt__p_Mezzanine__XML__ObjectRangeT_Mezzanine__XML__AttributeIterator_t = {"_p_Mezzanine__XML__ObjectRangeT_Mezzanine__XML__AttributeIterator_t", "Mezzanine::XML::ObjectRange< Mezzanine::XML::AttributeIterator > *", 0, 0, (void*)0, 0};
26617 static swig_type_info _swigt__p_Mezzanine__XML__ObjectRangeT_Mezzanine__XML__NamedNodeIterator_t = {"_p_Mezzanine__XML__ObjectRangeT_Mezzanine__XML__NamedNodeIterator_t", "Mezzanine::XML::ObjectRange< Mezzanine::XML::NamedNodeIterator > *", 0, 0, (void*)0, 0};
26618 static swig_type_info _swigt__p_Mezzanine__XML__ObjectRangeT_Mezzanine__XML__NodeIterator_t = {"_p_Mezzanine__XML__ObjectRangeT_Mezzanine__XML__NodeIterator_t", "Mezzanine::XML::ObjectRange< Mezzanine::XML::NodeIterator > *", 0, 0, (void*)0, 0};
26619 static swig_type_info _swigt__p_Mezzanine__XML__ParseResult = {"_p_Mezzanine__XML__ParseResult", "Mezzanine::XML::ParseResult *", 0, 0, (void*)&_wrap_class_Mezzanine_XML_ParseResult, 0};
26620 static swig_type_info _swigt__p_Mezzanine__XML__TreeWalker = {"_p_Mezzanine__XML__TreeWalker", "Mezzanine::XML::TreeWalker *", 0, 0, (void*)&_wrap_class_Mezzanine_XML_TreeWalker, 0};
26621 static swig_type_info _swigt__p_Mezzanine__XML__Writer = {"_p_Mezzanine__XML__Writer", "Mezzanine::XML::Writer *", 0, 0, (void*)&_wrap_class_Mezzanine_XML_Writer, 0};
26622 static swig_type_info _swigt__p_Mezzanine__XML__WriterFile = {"_p_Mezzanine__XML__WriterFile", "Mezzanine::XML::WriterFile *", 0, 0, (void*)&_wrap_class_Mezzanine_XML_WriterFile, 0};
26623 static swig_type_info _swigt__p_Mezzanine__XML__WriterStream = {"_p_Mezzanine__XML__WriterStream", "Mezzanine::XML::WriterStream *", 0, 0, (void*)&_wrap_class_Mezzanine_XML_WriterStream, 0};
26624 static swig_type_info _swigt__p_Mezzanine__XML__XMLStreamWrapper = {"_p_Mezzanine__XML__XMLStreamWrapper", "Mezzanine::XML::XMLStreamWrapper *", 0, 0, (void*)&_wrap_class_Mezzanine_XML_XMLStreamWrapper, 0};
26625 static swig_type_info _swigt__p_Mezzanine__XML__XPathNode = {"_p_Mezzanine__XML__XPathNode", "Mezzanine::XML::XPathNodeSet::const_iterator|Mezzanine::XML::XPathNode *", 0, 0, (void*)&_wrap_class_Mezzanine_XML_XPathNode, 0};
26626 static swig_type_info _swigt__p_Mezzanine__XML__XPathNodeSet = {"_p_Mezzanine__XML__XPathNodeSet", "Mezzanine::XML::XPathNodeSet *", 0, 0, (void*)&_wrap_class_Mezzanine_XML_XPathNodeSet, 0};
26627 static swig_type_info _swigt__p_Mezzanine__XML__XPathParseResult = {"_p_Mezzanine__XML__XPathParseResult", "Mezzanine::XML::XPathParseResult *", 0, 0, (void*)&_wrap_class_Mezzanine_XML_XPathParseResult, 0};
26628 static swig_type_info _swigt__p_Mezzanine__XML__XPathQuery = {"_p_Mezzanine__XML__XPathQuery", "Mezzanine::XML::XPathQuery *", 0, 0, (void*)&_wrap_class_Mezzanine_XML_XPathQuery, 0};
26629 static swig_type_info _swigt__p_Mezzanine__XML__XPathVariable = {"_p_Mezzanine__XML__XPathVariable", "Mezzanine::XML::XPathVariable *", 0, 0, (void*)&_wrap_class_Mezzanine_XML_XPathVariable, 0};
26630 static swig_type_info _swigt__p_Mezzanine__XML__XPathVariableSet = {"_p_Mezzanine__XML__XPathVariableSet", "Mezzanine::XML::XPathVariableSet *", 0, 0, (void*)&_wrap_class_Mezzanine_XML_XPathVariableSet, 0};
26631 static swig_type_info _swigt__p_Resource__DataStream = {"_p_Resource__DataStream", "Resource::DataStream *", 0, 0, (void*)0, 0};
26632 static swig_type_info _swigt__p_SDL_Event = {"_p_SDL_Event", "SDL_Event *|Mezzanine::RawEvent *", 0, 0, (void*)0, 0};
26633 static swig_type_info _swigt__p_attribute_iterator = {"_p_attribute_iterator", "attribute_iterator *", 0, 0, (void*)0, 0};
26634 static swig_type_info _swigt__p_bool = {"_p_bool", "bool *|Mezzanine::Boole *", 0, 0, (void*)0, 0};
26635 static swig_type_info _swigt__p_char = {"_p_char", "char *|Mezzanine::Char8 *", 0, 0, (void*)0, 0};
26636 static swig_type_info _swigt__p_difference_type = {"_p_difference_type", "difference_type *", 0, 0, (void*)0, 0};
26637 static swig_type_info _swigt__p_double = {"_p_double", "Mezzanine::PreciseReal *|double *", 0, 0, (void*)0, 0};
26638 static swig_type_info _swigt__p_f_p_void__void = {"_p_f_p_void__void", "Mezzanine::XML::DeAllocationFunction|void (*)(void *)", 0, 0, (void*)0, 0};
26639 static swig_type_info _swigt__p_f_size_t__p_void = {"_p_f_size_t__p_void", "void *(*)(size_t)|Mezzanine::XML::AllocationFunction", 0, 0, (void*)0, 0};
26640 static swig_type_info _swigt__p_float = {"_p_float", "float *|Mezzanine::Real *", 0, 0, (void*)0, 0};
26641 static swig_type_info _swigt__p_int = {"_p_int", "intptr_t *|int *|int_least32_t *|int_fast32_t *|Mezzanine::Int32 *|int32_t *|Mezzanine::ConvertiblePointer *|Mezzanine::Integer *|int_fast16_t *", 0, 0, (void*)0, 0};
26642 static swig_type_info _swigt__p_iterator = {"_p_iterator", "iterator *", 0, 0, (void*)0, 0};
26643 static swig_type_info _swigt__p_iterator_category = {"_p_iterator_category", "iterator_category *", 0, 0, (void*)0, 0};
26644 static swig_type_info _swigt__p_long_long = {"_p_long_long", "int_least64_t *|int_fast64_t *|Mezzanine::Int64 *|int64_t *|long long *|Mezzanine::MaxInt *|intmax_t *", 0, 0, (void*)0, 0};
26645 static swig_type_info _swigt__p_ptrdiff_t = {"_p_ptrdiff_t", "ptrdiff_t *", 0, 0, (void*)0, 0};
26646 static swig_type_info _swigt__p_short = {"_p_short", "Mezzanine::Int16 *|short *|int_least16_t *|int16_t *", 0, 0, (void*)0, 0};
26647 static swig_type_info _swigt__p_signed_char = {"_p_signed_char", "signed char *|Mezzanine::Int8 *|int_least8_t *|int_fast8_t *|int8_t *", 0, 0, (void*)0, 0};
26648 static swig_type_info _swigt__p_std__basic_istreamT_char_std__char_traitsT_char_t_t = {"_p_std__basic_istreamT_char_std__char_traitsT_char_t_t", "std::basic_istream< char,std::char_traits< char > > *", 0, 0, (void*)0, 0};
26649 static swig_type_info _swigt__p_std__basic_istreamT_wchar_t_std__char_traitsT_wchar_t_t_t = {"_p_std__basic_istreamT_wchar_t_std__char_traitsT_wchar_t_t_t", "std::basic_istream< wchar_t,std::char_traits< wchar_t > > *", 0, 0, (void*)0, 0};
26650 static swig_type_info _swigt__p_std__basic_ostreamT_char_std__char_traitsT_char_t_t = {"_p_std__basic_ostreamT_char_std__char_traitsT_char_t_t", "std::basic_ostream< char,std::char_traits< char > > *", 0, 0, (void*)0, 0};
26651 static swig_type_info _swigt__p_std__basic_ostreamT_wchar_t_std__char_traitsT_wchar_t_t_t = {"_p_std__basic_ostreamT_wchar_t_std__char_traitsT_wchar_t_t_t", "std::basic_ostream< wchar_t,std::char_traits< wchar_t > > *", 0, 0, (void*)0, 0};
26652 static swig_type_info _swigt__p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t = {"_p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t", "std::basic_string< char,std::char_traits< char >,std::allocator< char > > *", 0, 0, (void*)0, 0};
26653 static swig_type_info _swigt__p_std__basic_stringT_wchar_t_std__char_traitsT_wchar_t_t_std__allocatorT_wchar_t_t_t = {"_p_std__basic_stringT_wchar_t_std__char_traitsT_wchar_t_t_std__allocatorT_wchar_t_t_t", "std::basic_string< wchar_t,std::char_traits< wchar_t >,std::allocator< wchar_t > > *", 0, 0, (void*)0, 0};
26654 static swig_type_info _swigt__p_std__istream = {"_p_std__istream", "std::istream *", 0, 0, (void*)0, 0};
26655 static swig_type_info _swigt__p_std__listT_std__pairT_std__string_std__string_t_t = {"_p_std__listT_std__pairT_std__string_std__string_t_t", "Mezzanine::NameValuePairList *|std::list< std::pair< std::string,std::string > > *", 0, 0, (void*)0, 0};
26656 static swig_type_info _swigt__p_std__mapT_std__string_std__string_t = {"_p_std__mapT_std__string_std__string_t", "Mezzanine::NameValuePairMap *|std::map< std::string,std::string > *", 0, 0, (void*)0, 0};
26657 static swig_type_info _swigt__p_std__pairT_std__string_std__string_t = {"_p_std__pairT_std__string_std__string_t", "Mezzanine::NameValuePair *|std::pair< std::string,std::string > *", 0, 0, (void*)0, 0};
26658 static swig_type_info _swigt__p_std__setT_std__string_t = {"_p_std__setT_std__string_t", "std::set< std::string > *|Mezzanine::StringSet *", 0, 0, (void*)0, 0};
26659 static swig_type_info _swigt__p_std__string = {"_p_std__string", "std::string *|Mezzanine::String *|Mezzanine::ConstString *", 0, 0, (void*)&_wrap_class_std_string, 0};
26660 static swig_type_info _swigt__p_std__stringstream = {"_p_std__stringstream", "Mezzanine::Logger *|std::stringstream *|Mezzanine::StringStream *", 0, 0, (void*)0, 0};
26661 static swig_type_info _swigt__p_std__vectorT_std__string_t = {"_p_std__vectorT_std__string_t", "std::vector< std::string > *|Mezzanine::StringVector *", 0, 0, (void*)0, 0};
26662 static swig_type_info _swigt__p_std__wstring = {"_p_std__wstring", "std::wstring *|Mezzanine::WideString *", 0, 0, (void*)0, 0};
26663 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|Mezzanine::UInt8 *|uint_least8_t *|uint_fast8_t *|uint8_t *", 0, 0, (void*)0, 0};
26664 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "uintptr_t *|uint_least32_t *|uint_fast32_t *|uint32_t *|Mezzanine::UInt32 *|unsigned int *|Mezzanine::TimeMarker *|uint_fast16_t *", 0, 0, (void*)0, 0};
26665 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "Mezzanine::Whole *|unsigned long *", 0, 0, (void*)0, 0};
26666 static swig_type_info _swigt__p_unsigned_long_long = {"_p_unsigned_long_long", "uint_least64_t *|uint_fast64_t *|uint64_t *|Mezzanine::UInt64 *|unsigned long long *|uintmax_t *", 0, 0, (void*)0, 0};
26667 static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "Mezzanine::UInt16 *|unsigned short *|uint_least16_t *|uint16_t *", 0, 0, (void*)0, 0};
26668 static swig_type_info _swigt__p_value_type = {"_p_value_type", "value_type *", 0, 0, (void*)0, 0};
26669 static swig_type_info _swigt__p_wchar_t = {"_p_wchar_t", "wchar_t *", 0, 0, (void*)0, 0};
26670 
26671 static swig_type_info *swig_type_initial[] = {
26672  &_swigt__p_Mezzanine__Threading__RawFile,
26673  &_swigt__p_Mezzanine__Vector3,
26674  &_swigt__p_Mezzanine__XML__Attribute,
26675  &_swigt__p_Mezzanine__XML__AttributeIterator,
26676  &_swigt__p_Mezzanine__XML__AttributeStruct,
26677  &_swigt__p_Mezzanine__XML__Document,
26678  &_swigt__p_Mezzanine__XML__NamedNodeIterator,
26679  &_swigt__p_Mezzanine__XML__Node,
26680  &_swigt__p_Mezzanine__XML__NodeIterator,
26681  &_swigt__p_Mezzanine__XML__NodeStruct,
26682  &_swigt__p_Mezzanine__XML__NodeText,
26683  &_swigt__p_Mezzanine__XML__ObjectRangeT_Mezzanine__XML__AttributeIterator_t,
26684  &_swigt__p_Mezzanine__XML__ObjectRangeT_Mezzanine__XML__NamedNodeIterator_t,
26685  &_swigt__p_Mezzanine__XML__ObjectRangeT_Mezzanine__XML__NodeIterator_t,
26686  &_swigt__p_Mezzanine__XML__ParseResult,
26687  &_swigt__p_Mezzanine__XML__TreeWalker,
26688  &_swigt__p_Mezzanine__XML__Writer,
26689  &_swigt__p_Mezzanine__XML__WriterFile,
26690  &_swigt__p_Mezzanine__XML__WriterStream,
26691  &_swigt__p_Mezzanine__XML__XMLStreamWrapper,
26692  &_swigt__p_Mezzanine__XML__XPathNode,
26693  &_swigt__p_Mezzanine__XML__XPathNodeSet,
26694  &_swigt__p_Mezzanine__XML__XPathParseResult,
26695  &_swigt__p_Mezzanine__XML__XPathQuery,
26696  &_swigt__p_Mezzanine__XML__XPathVariable,
26697  &_swigt__p_Mezzanine__XML__XPathVariableSet,
26698  &_swigt__p_Resource__DataStream,
26699  &_swigt__p_SDL_Event,
26700  &_swigt__p_attribute_iterator,
26701  &_swigt__p_bool,
26702  &_swigt__p_char,
26703  &_swigt__p_difference_type,
26704  &_swigt__p_double,
26705  &_swigt__p_f_p_void__void,
26706  &_swigt__p_f_size_t__p_void,
26707  &_swigt__p_float,
26708  &_swigt__p_int,
26709  &_swigt__p_iterator,
26710  &_swigt__p_iterator_category,
26711  &_swigt__p_long_long,
26712  &_swigt__p_ptrdiff_t,
26713  &_swigt__p_short,
26714  &_swigt__p_signed_char,
26715  &_swigt__p_std__basic_istreamT_char_std__char_traitsT_char_t_t,
26716  &_swigt__p_std__basic_istreamT_wchar_t_std__char_traitsT_wchar_t_t_t,
26717  &_swigt__p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,
26718  &_swigt__p_std__basic_ostreamT_wchar_t_std__char_traitsT_wchar_t_t_t,
26719  &_swigt__p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,
26720  &_swigt__p_std__basic_stringT_wchar_t_std__char_traitsT_wchar_t_t_std__allocatorT_wchar_t_t_t,
26721  &_swigt__p_std__istream,
26722  &_swigt__p_std__listT_std__pairT_std__string_std__string_t_t,
26723  &_swigt__p_std__mapT_std__string_std__string_t,
26724  &_swigt__p_std__pairT_std__string_std__string_t,
26725  &_swigt__p_std__setT_std__string_t,
26726  &_swigt__p_std__string,
26727  &_swigt__p_std__stringstream,
26728  &_swigt__p_std__vectorT_std__string_t,
26729  &_swigt__p_std__wstring,
26730  &_swigt__p_unsigned_char,
26731  &_swigt__p_unsigned_int,
26732  &_swigt__p_unsigned_long,
26733  &_swigt__p_unsigned_long_long,
26734  &_swigt__p_unsigned_short,
26735  &_swigt__p_value_type,
26736  &_swigt__p_wchar_t,
26737 };
26738 
26739 static swig_cast_info _swigc__p_Mezzanine__Threading__RawFile[] = { {&_swigt__p_Mezzanine__Threading__RawFile, 0, 0, 0},{0, 0, 0, 0}};
26740 static swig_cast_info _swigc__p_Mezzanine__Vector3[] = { {&_swigt__p_Mezzanine__Vector3, 0, 0, 0},{0, 0, 0, 0}};
26741 static swig_cast_info _swigc__p_Mezzanine__XML__Attribute[] = { {&_swigt__p_Mezzanine__XML__Attribute, 0, 0, 0},{0, 0, 0, 0}};
26742 static swig_cast_info _swigc__p_Mezzanine__XML__AttributeIterator[] = { {&_swigt__p_Mezzanine__XML__AttributeIterator, 0, 0, 0},{0, 0, 0, 0}};
26743 static swig_cast_info _swigc__p_Mezzanine__XML__AttributeStruct[] = { {&_swigt__p_Mezzanine__XML__AttributeStruct, 0, 0, 0},{0, 0, 0, 0}};
26744 static swig_cast_info _swigc__p_Mezzanine__XML__Document[] = { {&_swigt__p_Mezzanine__XML__Document, 0, 0, 0},{0, 0, 0, 0}};
26745 static swig_cast_info _swigc__p_Mezzanine__XML__NamedNodeIterator[] = { {&_swigt__p_Mezzanine__XML__NamedNodeIterator, 0, 0, 0},{0, 0, 0, 0}};
26746 static swig_cast_info _swigc__p_Mezzanine__XML__Node[] = { {&_swigt__p_Mezzanine__XML__Node, 0, 0, 0}, {&_swigt__p_Mezzanine__XML__Document, _p_Mezzanine__XML__DocumentTo_p_Mezzanine__XML__Node, 0, 0},{0, 0, 0, 0}};
26747 static swig_cast_info _swigc__p_Mezzanine__XML__NodeIterator[] = { {&_swigt__p_Mezzanine__XML__NodeIterator, 0, 0, 0},{0, 0, 0, 0}};
26748 static swig_cast_info _swigc__p_Mezzanine__XML__NodeStruct[] = { {&_swigt__p_Mezzanine__XML__NodeStruct, 0, 0, 0},{0, 0, 0, 0}};
26749 static swig_cast_info _swigc__p_Mezzanine__XML__NodeText[] = { {&_swigt__p_Mezzanine__XML__NodeText, 0, 0, 0},{0, 0, 0, 0}};
26750 static swig_cast_info _swigc__p_Mezzanine__XML__ObjectRangeT_Mezzanine__XML__AttributeIterator_t[] = { {&_swigt__p_Mezzanine__XML__ObjectRangeT_Mezzanine__XML__AttributeIterator_t, 0, 0, 0},{0, 0, 0, 0}};
26751 static swig_cast_info _swigc__p_Mezzanine__XML__ObjectRangeT_Mezzanine__XML__NamedNodeIterator_t[] = { {&_swigt__p_Mezzanine__XML__ObjectRangeT_Mezzanine__XML__NamedNodeIterator_t, 0, 0, 0},{0, 0, 0, 0}};
26752 static swig_cast_info _swigc__p_Mezzanine__XML__ObjectRangeT_Mezzanine__XML__NodeIterator_t[] = { {&_swigt__p_Mezzanine__XML__ObjectRangeT_Mezzanine__XML__NodeIterator_t, 0, 0, 0},{0, 0, 0, 0}};
26753 static swig_cast_info _swigc__p_Mezzanine__XML__ParseResult[] = { {&_swigt__p_Mezzanine__XML__ParseResult, 0, 0, 0},{0, 0, 0, 0}};
26754 static swig_cast_info _swigc__p_Mezzanine__XML__TreeWalker[] = { {&_swigt__p_Mezzanine__XML__TreeWalker, 0, 0, 0},{0, 0, 0, 0}};
26755 static swig_cast_info _swigc__p_Mezzanine__XML__Writer[] = { {&_swigt__p_Mezzanine__XML__Writer, 0, 0, 0}, {&_swigt__p_Mezzanine__XML__XMLStreamWrapper, _p_Mezzanine__XML__XMLStreamWrapperTo_p_Mezzanine__XML__Writer, 0, 0}, {&_swigt__p_Mezzanine__XML__WriterFile, _p_Mezzanine__XML__WriterFileTo_p_Mezzanine__XML__Writer, 0, 0}, {&_swigt__p_Mezzanine__XML__WriterStream, _p_Mezzanine__XML__WriterStreamTo_p_Mezzanine__XML__Writer, 0, 0},{0, 0, 0, 0}};
26756 static swig_cast_info _swigc__p_Mezzanine__XML__WriterFile[] = { {&_swigt__p_Mezzanine__XML__WriterFile, 0, 0, 0},{0, 0, 0, 0}};
26757 static swig_cast_info _swigc__p_Mezzanine__XML__WriterStream[] = { {&_swigt__p_Mezzanine__XML__WriterStream, 0, 0, 0},{0, 0, 0, 0}};
26758 static swig_cast_info _swigc__p_Mezzanine__XML__XMLStreamWrapper[] = { {&_swigt__p_Mezzanine__XML__XMLStreamWrapper, 0, 0, 0},{0, 0, 0, 0}};
26759 static swig_cast_info _swigc__p_Mezzanine__XML__XPathNode[] = { {&_swigt__p_Mezzanine__XML__XPathNode, 0, 0, 0},{0, 0, 0, 0}};
26760 static swig_cast_info _swigc__p_Mezzanine__XML__XPathNodeSet[] = { {&_swigt__p_Mezzanine__XML__XPathNodeSet, 0, 0, 0},{0, 0, 0, 0}};
26761 static swig_cast_info _swigc__p_Mezzanine__XML__XPathParseResult[] = { {&_swigt__p_Mezzanine__XML__XPathParseResult, 0, 0, 0},{0, 0, 0, 0}};
26762 static swig_cast_info _swigc__p_Mezzanine__XML__XPathQuery[] = { {&_swigt__p_Mezzanine__XML__XPathQuery, 0, 0, 0},{0, 0, 0, 0}};
26763 static swig_cast_info _swigc__p_Mezzanine__XML__XPathVariable[] = { {&_swigt__p_Mezzanine__XML__XPathVariable, 0, 0, 0},{0, 0, 0, 0}};
26764 static swig_cast_info _swigc__p_Mezzanine__XML__XPathVariableSet[] = { {&_swigt__p_Mezzanine__XML__XPathVariableSet, 0, 0, 0},{0, 0, 0, 0}};
26765 static swig_cast_info _swigc__p_Resource__DataStream[] = { {&_swigt__p_Resource__DataStream, 0, 0, 0},{0, 0, 0, 0}};
26766 static swig_cast_info _swigc__p_SDL_Event[] = { {&_swigt__p_SDL_Event, 0, 0, 0},{0, 0, 0, 0}};
26767 static swig_cast_info _swigc__p_attribute_iterator[] = { {&_swigt__p_attribute_iterator, 0, 0, 0},{0, 0, 0, 0}};
26768 static swig_cast_info _swigc__p_bool[] = { {&_swigt__p_bool, 0, 0, 0},{0, 0, 0, 0}};
26769 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
26770 static swig_cast_info _swigc__p_difference_type[] = { {&_swigt__p_difference_type, 0, 0, 0},{0, 0, 0, 0}};
26771 static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
26772 static swig_cast_info _swigc__p_f_p_void__void[] = { {&_swigt__p_f_p_void__void, 0, 0, 0},{0, 0, 0, 0}};
26773 static swig_cast_info _swigc__p_f_size_t__p_void[] = { {&_swigt__p_f_size_t__p_void, 0, 0, 0},{0, 0, 0, 0}};
26774 static swig_cast_info _swigc__p_float[] = { {&_swigt__p_float, 0, 0, 0},{0, 0, 0, 0}};
26775 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
26776 static swig_cast_info _swigc__p_iterator[] = { {&_swigt__p_iterator, 0, 0, 0},{0, 0, 0, 0}};
26777 static swig_cast_info _swigc__p_iterator_category[] = { {&_swigt__p_iterator_category, 0, 0, 0},{0, 0, 0, 0}};
26778 static swig_cast_info _swigc__p_long_long[] = { {&_swigt__p_long_long, 0, 0, 0},{0, 0, 0, 0}};
26779 static swig_cast_info _swigc__p_ptrdiff_t[] = { {&_swigt__p_ptrdiff_t, 0, 0, 0},{0, 0, 0, 0}};
26780 static swig_cast_info _swigc__p_short[] = { {&_swigt__p_short, 0, 0, 0},{0, 0, 0, 0}};
26781 static swig_cast_info _swigc__p_signed_char[] = { {&_swigt__p_signed_char, 0, 0, 0},{0, 0, 0, 0}};
26782 static swig_cast_info _swigc__p_std__basic_istreamT_char_std__char_traitsT_char_t_t[] = { {&_swigt__p_std__basic_istreamT_char_std__char_traitsT_char_t_t, 0, 0, 0},{0, 0, 0, 0}};
26783 static swig_cast_info _swigc__p_std__basic_istreamT_wchar_t_std__char_traitsT_wchar_t_t_t[] = { {&_swigt__p_std__basic_istreamT_wchar_t_std__char_traitsT_wchar_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
26784 static swig_cast_info _swigc__p_std__basic_ostreamT_char_std__char_traitsT_char_t_t[] = { {&_swigt__p_std__basic_ostreamT_char_std__char_traitsT_char_t_t, 0, 0, 0},{0, 0, 0, 0}};
26785 static swig_cast_info _swigc__p_std__basic_ostreamT_wchar_t_std__char_traitsT_wchar_t_t_t[] = { {&_swigt__p_std__basic_ostreamT_wchar_t_std__char_traitsT_wchar_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
26786 static swig_cast_info _swigc__p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t[] = { {&_swigt__p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t, 0, 0, 0},{0, 0, 0, 0}};
26787 static swig_cast_info _swigc__p_std__basic_stringT_wchar_t_std__char_traitsT_wchar_t_t_std__allocatorT_wchar_t_t_t[] = { {&_swigt__p_std__basic_stringT_wchar_t_std__char_traitsT_wchar_t_t_std__allocatorT_wchar_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
26788 static swig_cast_info _swigc__p_std__istream[] = { {&_swigt__p_std__istream, 0, 0, 0},{0, 0, 0, 0}};
26789 static swig_cast_info _swigc__p_std__listT_std__pairT_std__string_std__string_t_t[] = { {&_swigt__p_std__listT_std__pairT_std__string_std__string_t_t, 0, 0, 0},{0, 0, 0, 0}};
26790 static swig_cast_info _swigc__p_std__mapT_std__string_std__string_t[] = { {&_swigt__p_std__mapT_std__string_std__string_t, 0, 0, 0},{0, 0, 0, 0}};
26791 static swig_cast_info _swigc__p_std__pairT_std__string_std__string_t[] = { {&_swigt__p_std__pairT_std__string_std__string_t, 0, 0, 0},{0, 0, 0, 0}};
26792 static swig_cast_info _swigc__p_std__setT_std__string_t[] = { {&_swigt__p_std__setT_std__string_t, 0, 0, 0},{0, 0, 0, 0}};
26793 static swig_cast_info _swigc__p_std__string[] = { {&_swigt__p_std__string, 0, 0, 0},{0, 0, 0, 0}};
26794 static swig_cast_info _swigc__p_std__stringstream[] = { {&_swigt__p_std__stringstream, 0, 0, 0},{0, 0, 0, 0}};
26795 static swig_cast_info _swigc__p_std__vectorT_std__string_t[] = { {&_swigt__p_std__vectorT_std__string_t, 0, 0, 0},{0, 0, 0, 0}};
26796 static swig_cast_info _swigc__p_std__wstring[] = { {&_swigt__p_std__wstring, 0, 0, 0},{0, 0, 0, 0}};
26797 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
26798 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
26799 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
26800 static swig_cast_info _swigc__p_unsigned_long_long[] = { {&_swigt__p_unsigned_long_long, 0, 0, 0},{0, 0, 0, 0}};
26801 static swig_cast_info _swigc__p_unsigned_short[] = { {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}};
26802 static swig_cast_info _swigc__p_value_type[] = { {&_swigt__p_value_type, 0, 0, 0},{0, 0, 0, 0}};
26803 static swig_cast_info _swigc__p_wchar_t[] = { {&_swigt__p_wchar_t, 0, 0, 0},{0, 0, 0, 0}};
26804 
26805 static swig_cast_info *swig_cast_initial[] = {
26806  _swigc__p_Mezzanine__Threading__RawFile,
26807  _swigc__p_Mezzanine__Vector3,
26808  _swigc__p_Mezzanine__XML__Attribute,
26809  _swigc__p_Mezzanine__XML__AttributeIterator,
26810  _swigc__p_Mezzanine__XML__AttributeStruct,
26811  _swigc__p_Mezzanine__XML__Document,
26812  _swigc__p_Mezzanine__XML__NamedNodeIterator,
26813  _swigc__p_Mezzanine__XML__Node,
26814  _swigc__p_Mezzanine__XML__NodeIterator,
26815  _swigc__p_Mezzanine__XML__NodeStruct,
26816  _swigc__p_Mezzanine__XML__NodeText,
26817  _swigc__p_Mezzanine__XML__ObjectRangeT_Mezzanine__XML__AttributeIterator_t,
26818  _swigc__p_Mezzanine__XML__ObjectRangeT_Mezzanine__XML__NamedNodeIterator_t,
26819  _swigc__p_Mezzanine__XML__ObjectRangeT_Mezzanine__XML__NodeIterator_t,
26820  _swigc__p_Mezzanine__XML__ParseResult,
26821  _swigc__p_Mezzanine__XML__TreeWalker,
26822  _swigc__p_Mezzanine__XML__Writer,
26823  _swigc__p_Mezzanine__XML__WriterFile,
26824  _swigc__p_Mezzanine__XML__WriterStream,
26825  _swigc__p_Mezzanine__XML__XMLStreamWrapper,
26826  _swigc__p_Mezzanine__XML__XPathNode,
26827  _swigc__p_Mezzanine__XML__XPathNodeSet,
26828  _swigc__p_Mezzanine__XML__XPathParseResult,
26829  _swigc__p_Mezzanine__XML__XPathQuery,
26830  _swigc__p_Mezzanine__XML__XPathVariable,
26831  _swigc__p_Mezzanine__XML__XPathVariableSet,
26832  _swigc__p_Resource__DataStream,
26833  _swigc__p_SDL_Event,
26834  _swigc__p_attribute_iterator,
26835  _swigc__p_bool,
26836  _swigc__p_char,
26837  _swigc__p_difference_type,
26838  _swigc__p_double,
26839  _swigc__p_f_p_void__void,
26840  _swigc__p_f_size_t__p_void,
26841  _swigc__p_float,
26842  _swigc__p_int,
26843  _swigc__p_iterator,
26844  _swigc__p_iterator_category,
26845  _swigc__p_long_long,
26846  _swigc__p_ptrdiff_t,
26847  _swigc__p_short,
26848  _swigc__p_signed_char,
26849  _swigc__p_std__basic_istreamT_char_std__char_traitsT_char_t_t,
26850  _swigc__p_std__basic_istreamT_wchar_t_std__char_traitsT_wchar_t_t_t,
26851  _swigc__p_std__basic_ostreamT_char_std__char_traitsT_char_t_t,
26852  _swigc__p_std__basic_ostreamT_wchar_t_std__char_traitsT_wchar_t_t_t,
26853  _swigc__p_std__basic_stringT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,
26854  _swigc__p_std__basic_stringT_wchar_t_std__char_traitsT_wchar_t_t_std__allocatorT_wchar_t_t_t,
26855  _swigc__p_std__istream,
26856  _swigc__p_std__listT_std__pairT_std__string_std__string_t_t,
26857  _swigc__p_std__mapT_std__string_std__string_t,
26858  _swigc__p_std__pairT_std__string_std__string_t,
26859  _swigc__p_std__setT_std__string_t,
26860  _swigc__p_std__string,
26861  _swigc__p_std__stringstream,
26862  _swigc__p_std__vectorT_std__string_t,
26863  _swigc__p_std__wstring,
26864  _swigc__p_unsigned_char,
26865  _swigc__p_unsigned_int,
26866  _swigc__p_unsigned_long,
26867  _swigc__p_unsigned_long_long,
26868  _swigc__p_unsigned_short,
26869  _swigc__p_value_type,
26870  _swigc__p_wchar_t,
26871 };
26872 
26873 
26874 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
26875 
26876 /* -----------------------------------------------------------------------------
26877  * Type initialization:
26878  * This problem is tough by the requirement that no dynamic
26879  * memory is used. Also, since swig_type_info structures store pointers to
26880  * swig_cast_info structures and swig_cast_info structures store pointers back
26881  * to swig_type_info structures, we need some lookup code at initialization.
26882  * The idea is that swig generates all the structures that are needed.
26883  * The runtime then collects these partially filled structures.
26884  * The SWIG_InitializeModule function takes these initial arrays out of
26885  * swig_module, and does all the lookup, filling in the swig_module.types
26886  * array with the correct data and linking the correct swig_cast_info
26887  * structures together.
26888  *
26889  * The generated swig_type_info structures are assigned staticly to an initial
26890  * array. We just loop through that array, and handle each type individually.
26891  * First we lookup if this type has been already loaded, and if so, use the
26892  * loaded structure instead of the generated one. Then we have to fill in the
26893  * cast linked list. The cast data is initially stored in something like a
26894  * two-dimensional array. Each row corresponds to a type (there are the same
26895  * number of rows as there are in the swig_type_initial array). Each entry in
26896  * a column is one of the swig_cast_info structures for that type.
26897  * The cast_initial array is actually an array of arrays, because each row has
26898  * a variable number of columns. So to actually build the cast linked list,
26899  * we find the array of casts associated with the type, and loop through it
26900  * adding the casts to the list. The one last trick we need to do is making
26901  * sure the type pointer in the swig_cast_info struct is correct.
26902  *
26903  * First off, we lookup the cast->type name to see if it is already loaded.
26904  * There are three cases to handle:
26905  * 1) If the cast->type has already been loaded AND the type we are adding
26906  * casting info to has not been loaded (it is in this module), THEN we
26907  * replace the cast->type pointer with the type pointer that has already
26908  * been loaded.
26909  * 2) If BOTH types (the one we are adding casting info to, and the
26910  * cast->type) are loaded, THEN the cast info has already been loaded by
26911  * the previous module so we just ignore it.
26912  * 3) Finally, if cast->type has not already been loaded, then we add that
26913  * swig_cast_info to the linked list (because the cast->type) pointer will
26914  * be correct.
26915  * ----------------------------------------------------------------------------- */
26916 
26917 #ifdef __cplusplus
26918 extern "C" {
26919 #if 0
26920 } /* c-mode */
26921 #endif
26922 #endif
26923 
26924 #if 0
26925 #define SWIGRUNTIME_DEBUG
26926 #endif
26927 
26928 
26929 SWIGRUNTIME void
26930 SWIG_InitializeModule(void *clientdata) {
26931  size_t i;
26932  swig_module_info *module_head, *iter;
26933  int found, init;
26934 
26935  /* check to see if the circular list has been setup, if not, set it up */
26936  if (swig_module.next==0) {
26937  /* Initialize the swig_module */
26938  swig_module.type_initial = swig_type_initial;
26939  swig_module.cast_initial = swig_cast_initial;
26940  swig_module.next = &swig_module;
26941  init = 1;
26942  } else {
26943  init = 0;
26944  }
26945 
26946  /* Try and load any already created modules */
26947  module_head = SWIG_GetModule(clientdata);
26948  if (!module_head) {
26949  /* This is the first module loaded for this interpreter */
26950  /* so set the swig module into the interpreter */
26951  SWIG_SetModule(clientdata, &swig_module);
26952  module_head = &swig_module;
26953  } else {
26954  /* the interpreter has loaded a SWIG module, but has it loaded this one? */
26955  found=0;
26956  iter=module_head;
26957  do {
26958  if (iter==&swig_module) {
26959  found=1;
26960  break;
26961  }
26962  iter=iter->next;
26963  } while (iter!= module_head);
26964 
26965  /* if the is found in the list, then all is done and we may leave */
26966  if (found) return;
26967  /* otherwise we must add out module into the list */
26968  swig_module.next = module_head->next;
26969  module_head->next = &swig_module;
26970  }
26971 
26972  /* When multiple interpeters are used, a module could have already been initialized in
26973  a different interpreter, but not yet have a pointer in this interpreter.
26974  In this case, we do not want to continue adding types... everything should be
26975  set up already */
26976  if (init == 0) return;
26977 
26978  /* Now work on filling in swig_module.types */
26979 #ifdef SWIGRUNTIME_DEBUG
26980  printf("SWIG_InitializeModule: size %d\n", swig_module.size);
26981 #endif
26982  for (i = 0; i < swig_module.size; ++i) {
26983  swig_type_info *type = 0;
26984  swig_type_info *ret;
26985  swig_cast_info *cast;
26986 
26987 #ifdef SWIGRUNTIME_DEBUG
26988  printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
26989 #endif
26990 
26991  /* if there is another module already loaded */
26992  if (swig_module.next != &swig_module) {
26993  type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
26994  }
26995  if (type) {
26996  /* Overwrite clientdata field */
26997 #ifdef SWIGRUNTIME_DEBUG
26998  printf("SWIG_InitializeModule: found type %s\n", type->name);
26999 #endif
27000  if (swig_module.type_initial[i]->clientdata) {
27001  type->clientdata = swig_module.type_initial[i]->clientdata;
27002 #ifdef SWIGRUNTIME_DEBUG
27003  printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
27004 #endif
27005  }
27006  } else {
27007  type = swig_module.type_initial[i];
27008  }
27009 
27010  /* Insert casting types */
27011  cast = swig_module.cast_initial[i];
27012  while (cast->type) {
27013 
27014  /* Don't need to add information already in the list */
27015  ret = 0;
27016 #ifdef SWIGRUNTIME_DEBUG
27017  printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
27018 #endif
27019  if (swig_module.next != &swig_module) {
27020  ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
27021 #ifdef SWIGRUNTIME_DEBUG
27022  if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
27023 #endif
27024  }
27025  if (ret) {
27026  if (type == swig_module.type_initial[i]) {
27027 #ifdef SWIGRUNTIME_DEBUG
27028  printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
27029 #endif
27030  cast->type = ret;
27031  ret = 0;
27032  } else {
27033  /* Check for casting already in the list */
27034  swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
27035 #ifdef SWIGRUNTIME_DEBUG
27036  if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
27037 #endif
27038  if (!ocast) ret = 0;
27039  }
27040  }
27041 
27042  if (!ret) {
27043 #ifdef SWIGRUNTIME_DEBUG
27044  printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
27045 #endif
27046  if (type->cast) {
27047  type->cast->prev = cast;
27048  cast->next = type->cast;
27049  }
27050  type->cast = cast;
27051  }
27052  cast++;
27053  }
27054  /* Set entry in modules->types array equal to the type */
27055  swig_module.types[i] = type;
27056  }
27057  swig_module.types[i] = 0;
27058 
27059 #ifdef SWIGRUNTIME_DEBUG
27060  printf("**** SWIG_InitializeModule: Cast List ******\n");
27061  for (i = 0; i < swig_module.size; ++i) {
27062  int j = 0;
27063  swig_cast_info *cast = swig_module.cast_initial[i];
27064  printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
27065  while (cast->type) {
27066  printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
27067  cast++;
27068  ++j;
27069  }
27070  printf("---- Total casts: %d\n",j);
27071  }
27072  printf("**** SWIG_InitializeModule: Cast List ******\n");
27073 #endif
27074 }
27075 
27076 /* This function will propagate the clientdata field of type to
27077 * any new swig_type_info structures that have been added into the list
27078 * of equivalent types. It is like calling
27079 * SWIG_TypeClientData(type, clientdata) a second time.
27080 */
27081 SWIGRUNTIME void
27082 SWIG_PropagateClientData(void) {
27083  size_t i;
27084  swig_cast_info *equiv;
27085  static int init_run = 0;
27086 
27087  if (init_run) return;
27088  init_run = 1;
27089 
27090  for (i = 0; i < swig_module.size; i++) {
27091  if (swig_module.types[i]->clientdata) {
27092  equiv = swig_module.types[i]->cast;
27093  while (equiv) {
27094  if (!equiv->converter) {
27095  if (equiv->type && !equiv->type->clientdata)
27096  SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
27097  }
27098  equiv = equiv->next;
27099  }
27100  }
27101  }
27102 }
27103 
27104 #ifdef __cplusplus
27105 #if 0
27106 { /* c-mode */
27107 #endif
27108 }
27109 #endif
27110 
27111 
27112 
27113 /* Forward declaration of where the user's %init{} gets inserted */
27114 void SWIG_init_user(lua_State* L );
27115 
27116 #ifdef __cplusplus
27117 extern "C" {
27118 #endif
27119 /* this is the initialization function
27120  added at the very end of the code
27121  the function is always called SWIG_init, but an earlier #define will rename it
27122 */
27123 #if ((SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC))
27124 LUALIB_API int SWIG_init(lua_State* L)
27125 #else
27126 SWIGEXPORT int SWIG_init(lua_State* L) /* default Lua action */
27127 #endif
27128 {
27129 #if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC) /* valid for both Lua and eLua */
27130  int i;
27131  /* start with global table */
27132  lua_pushglobaltable (L);
27133  /* SWIG's internal initalisation */
27134  SWIG_InitializeModule((void*)L);
27135  SWIG_PropagateClientData();
27136 #endif
27137 
27138 #if ((SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUA) && (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC))
27139  /* add a global fn */
27140  SWIG_Lua_add_function(L,"swig_type",SWIG_Lua_type);
27141  SWIG_Lua_add_function(L,"swig_equals",SWIG_Lua_equal);
27142  /* begin the module (its a table with the same name as the module) */
27143  SWIG_Lua_module_begin(L,SWIG_name);
27144  /* add commands/functions */
27145  for (i = 0; swig_commands[i].name; i++){
27146  SWIG_Lua_module_add_function(L,swig_commands[i].name,swig_commands[i].func);
27147  }
27148  /* add variables */
27149  for (i = 0; swig_variables[i].name; i++){
27150  SWIG_Lua_module_add_variable(L,swig_variables[i].name,swig_variables[i].get,swig_variables[i].set);
27151  }
27152 #endif
27153 
27154 #if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC)
27155  /* set up base class pointers (the hierarchy) */
27156  for (i = 0; swig_types[i]; i++){
27157  if (swig_types[i]->clientdata){
27158  SWIG_Lua_init_base_class(L,(swig_lua_class*)(swig_types[i]->clientdata));
27159  }
27160  }
27161  /* additional registration structs & classes in lua */
27162  for (i = 0; swig_types[i]; i++){
27163  if (swig_types[i]->clientdata){
27164  SWIG_Lua_class_register(L,(swig_lua_class*)(swig_types[i]->clientdata));
27165  }
27166  }
27167 #endif
27168 
27169 #if ((SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUA) && (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC))
27170  /* constants */
27171  SWIG_Lua_InstallConstants(L,swig_constants);
27172 #endif
27173 
27174 #if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC)
27175  /* invoke user-specific initialization */
27176  SWIG_init_user(L);
27177  /* end module */
27178  /* Note: We do not clean up the stack here (Lua will do this for us). At this
27179  point, we have the globals table and out module table on the stack. Returning
27180  one value makes the module table the result of the require command. */
27181  return 1;
27182 #else
27183  return 0;
27184 #endif
27185 }
27186 
27187 #ifdef __cplusplus
27188 }
27189 #endif
27190 
27191 
27192 const char* SWIG_LUACODE=
27193  "";
27194 
27195 void SWIG_init_user(lua_State* L)
27196 {
27197  /* exec Lua code if applicable */
27198  SWIG_Lua_dostring(L,SWIG_LUACODE);
27199 }
27200